ruleTester.run("no-useless-removeEventListener", rule, {
valid: [
// Listeners that aren't a function are always valid.
"elt.addEventListener('click', handler);",
"elt.addEventListener('click', handler, true);",
"elt.addEventListener('click', handler, {once: true});",
// Should not fail on empty functions.
"elt.addEventListener('click', function() {});",
// Should not reject when removing a listener for another event.
"elt.addEventListener('click', function listener() {" +
" elt.removeEventListener('keypress', listener);" +
"});",
// Should not reject when there's another instruction before
// removeEventListener.
"elt.addEventListener('click', function listener() {" +
" elt.focus();" +
" elt.removeEventListener('click', listener);" +
"});",
// Should not reject when wantsUntrusted is true.
"elt.addEventListener('click', function listener() {" +
" elt.removeEventListener('click', listener);" +
"}, false, true);",
// Should not reject when there's a literal and a variable
"elt.addEventListener('click', function listener() {" +
" elt.removeEventListener(eventName, listener);" +
"});",
// Should not reject when there's 2 different variables
"elt.addEventListener(event1, function listener() {" +
" elt.removeEventListener(event2, listener);" +
"});"
],
invalid: [
invalidCode("elt.addEventListener('click', function listener() {" +
" elt.removeEventListener('click', listener);" +
"});"),
invalidCode("elt.addEventListener('click', function listener() {" +
" elt.removeEventListener('click', listener, true);" +
"}, true);"),
invalidCode("elt.addEventListener('click', function listener() {" +
" elt.removeEventListener('click', listener);" +
"}, {once: true});"),
invalidCode("elt.addEventListener('click', function listener() {" +
" /* Comment */" +
" elt.removeEventListener('click', listener);" +
"});"),
invalidCode("elt.addEventListener('click', function() {" +
" elt.removeEventListener('click', arguments.callee);" +
"});"),
invalidCode("elt.addEventListener(eventName, function listener() {" +
" elt.removeEventListener(eventName, listener);" +
"});")
]
});
ruleTester.run("no-unhandled-errors", rule, {
valid: [
{
code: buildTest(
"import { take } from 'redux-saga'",
"try { yield take('ACTION') } catch (e) { errorHandler(e) }"
)
},
{
code: buildTest(
"import { take as t } from 'redux-saga'",
"try { yield t('ACTION') } catch (e) { errorHandler(e) }"
)
},
{
code: buildTest(
"import { take } from 'redux-saga/effects'",
"try { yield take('ACTION') } catch (e) { errorHandler(e) }"
)
},
{
code: buildTest(null, "try { yield take('ACTION') } catch (e) { errorHandler(e) }")
},
{
code: buildTest("import { take } from 'redux-saga'", "notAnEffectDoesNotNeedYield()")
},
{
code: "import createSagaMiddleware from 'redux-saga'; const sagaMiddleware = createSagaMiddleware();"
},
{
code: buildTest("import { noop } from 'redux-saga'", "noop()")
},
{
code: buildTest(
"import { call } from 'redux-saga'",
"try { yield call('ACTION') } catch (e) { errorHandler(e) }"
)
},
{
code: buildTest(
"import { call } from 'redux-saga'",
"try { someStuff() } catch (e) { yield call('ACTION') }"
)
},
{
code: buildTest(
"import { call, fork } from 'redux-saga/effects'",
"yield fork(function*(){})"
)
},
{
code: buildTest(
"import { takeEvery, takeLatest, throttle } from 'redux-saga'",
"yield takeEvery('ACTION', function*(){});" +
"yield takeLatest('ACTION', function*(){});" +
"yield throttle('ACTION', function*(){})"
)
}
],
invalid: [
{
code: buildTest("import { call } from 'redux-saga'", "yield call('ACTION')"),
errors: [{message: "A Saga must handle its effects' errors (use try/catch)"}]
},
{
code: buildTest("import { put as p } from 'redux-saga'", "yield p('ACTION')"),
errors: [{message: "A Saga must handle its effects' errors (use try/catch)"}]
},
{
code: buildTest(
"import { call } from 'redux-saga'",
"try { yield call('ACTION') } catch (e) { errorHandler(e) } yield call('ACTION')"
),
errors: [{message: "A Saga must handle its effects' errors (use try/catch)"}]
}
]
})
const ruleTester = new RuleTester({ parserOptions: { ecmaVersion: 6 } });
// ------------------------------------------------------------------------------
// Tests
// ------------------------------------------------------------------------------
function wrapCode(code, filename = "xpcshell/test_foo.js") {
return {code, filename};
}
function invalidCode(code) {
let message = "listen for events instead of setTimeout() with arbitrary delay";
let obj = wrapCode(code);
obj.errors = [{message, type: "CallExpression"}];
return obj;
}
ruleTester.run("no-arbitrary-setTimeout", rule, {
valid: [
wrapCode("setTimeout(function() {}, 0);"),
wrapCode("setTimeout(function() {});"),
wrapCode("setTimeout(function() {}, 10);", "test_foo.js")
],
invalid: [
invalidCode("setTimeout(function() {}, 10);"),
invalidCode("setTimeout(function() {}, timeout);")
]
});
ruleTester.run("no-callback-in-generator", rule, {
valid: [
"function foo() { function bar() {} }",
{
code: "function foo() { bar((err) => {}); }",
parserOptions: {
ecmaVersion: 6,
},
}, {
code: "function* foo() { yield new Promise((resolve) => { return resolve(); });}",
parserOptions: {
ecmaVersion: 6,
},
}, {
code: "function* foo() { bar.map((item) => { return bar.name; }); }",
parserOptions: {
ecmaVersion: 6,
},
}, {
code: "function* foo() { yield bar.foobar(); }",
parserOptions: {
ecmaVersion: 6,
},
},
],
invalid: [
{
code: "function* foo() { bar.foobar((err) => {}); }",
parserOptions: {
ecmaVersion: 6,
},
errors: [{
message: "Callback defined inside of a generator function.",
type: "ArrowFunctionExpression",
}],
}, {
code: "function* foo() { bar.foobar(function (err) {}); }",
parserOptions: {
ecmaVersion: 6,
},
errors: [{
message: "Callback defined inside of a generator function.",
type: "FunctionExpression",
}],
},
],
});
ruleTester.run("no-useless-run-test", rule, {
valid: [
"function run_test() {}",
"function run_test() {let args = 1; run_next_test();}",
"function run_test() {fakeCall(); run_next_test();}"
],
invalid: [
// Single-line case.
invalidCode(
"function run_test() { run_next_test(); }",
""),
// Multiple-line cases
invalidCode(`
function run_test() {
run_next_test();
}`,
``),
invalidCode(`
foo();
function run_test() {
run_next_test();
}
`,
`
foo();
`),
invalidCode(`
foo();
function run_test() {
run_next_test();
}
bar();
`,
`
foo();
bar();
`),
invalidCode(`
foo();
function run_test() {
run_next_test();
}
bar();`,
`
foo();
bar();`),
invalidCode(`
foo();
function run_test() {
run_next_test();
}
// A comment
bar();
`,
`
foo();
// A comment
bar();
`),
invalidCode(`
foo();
/**
* A useful comment.
*/
function run_test() {
run_next_test();
}
// A comment
bar();
`,
`
foo();
/**
* A useful comment.
*/
// A comment
bar();
`)
]
});
ruleTester.run("use-chromeutils-import", rule, {
valid: [
`ChromeUtils.import("resource://gre/modules/Service.jsm");`,
`ChromeUtils.import("resource://gre/modules/Service.jsm", this);`,
`ChromeUtils.defineModuleGetter(this, "Services",
"resource://gre/modules/Service.jsm");`,
`XPCOMUtils.defineLazyModuleGetter(this, "Services",
"resource://gre/modules/Service.jsm",
"Foo");`,
`XPCOMUtils.defineLazyModuleGetter(this, "Services",
"resource://gre/modules/Service.jsm",
undefined, preServicesLambda);`,
{
options: [{allowCu: true}],
code: `Cu.import("resource://gre/modules/Service.jsm");`
}
],
invalid: [
{
code: `Cu.import("resource://gre/modules/Services.jsm");`,
output: `ChromeUtils.import("resource://gre/modules/Services.jsm");`,
errors: callError(MESSAGE_IMPORT)
},
{
code: `Cu.import("resource://gre/modules/Services.jsm", this);`,
output: `ChromeUtils.import("resource://gre/modules/Services.jsm", this);`,
errors: callError(MESSAGE_IMPORT)
},
{
code: `Components.utils.import("resource://gre/modules/Services.jsm");`,
output: `ChromeUtils.import("resource://gre/modules/Services.jsm");`,
errors: callError(MESSAGE_IMPORT)
},
{
code: `Components.utils.import("resource://gre/modules/Services.jsm");`,
output: `ChromeUtils.import("resource://gre/modules/Services.jsm");`,
errors: callError(MESSAGE_IMPORT)
},
{
options: [{allowCu: true}],
code: `Components.utils.import("resource://gre/modules/Services.jsm", this);`,
output: `ChromeUtils.import("resource://gre/modules/Services.jsm", this);`,
errors: callError(MESSAGE_IMPORT)
},
{
code: `XPCOMUtils.defineLazyModuleGetter(this, "Services",
"resource://gre/modules/Services.jsm");`,
output: `ChromeUtils.defineModuleGetter(this, "Services",
"resource://gre/modules/Services.jsm");`,
errors: callError(MESSAGE_DEFINE)
}
]
});