[pve-eslint.git] / eslint / tests / lib / rules / require-jsdoc.js

/**
 * @fileoverview Test file for require-jsdoc rule
 * @author Gyandeep Singh
 */
"use strict";

//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------

const rule = require("../../../lib/rules/require-jsdoc"),
    { RuleTester } = require("../../../lib/rule-tester");

//------------------------------------------------------------------------------
// Tests
//------------------------------------------------------------------------------

const ruleTester = new RuleTester();

ruleTester.run("require-jsdoc", rule, {
    valid: [
        "var array = [1,2,3];\narray.forEach(function() {});",
        "/**\n @class MyClass \n*/\nfunction MyClass() {}",
        "/**\n Function doing something\n*/\nfunction myFunction() {}",
        "/**\n Function doing something\n*/\nvar myFunction = function() {};",
        "/**\n Function doing something\n*/\nObject.myFunction = function () {};",
        "var obj = { \n /**\n Function doing something\n*/\n myFunction: function () {} };",

        "/**\n @func myFunction \n*/\nfunction myFunction() {}",
        "/**\n @method myFunction\n*/\nfunction myFunction() {}",
        "/**\n @function myFunction\n*/\nfunction myFunction() {}",

        "/**\n @func myFunction \n*/\nvar myFunction = function () {}",
        "/**\n @method myFunction\n*/\nvar myFunction = function () {}",
        "/**\n @function myFunction\n*/\nvar myFunction = function () {}",

        "/**\n @func myFunction \n*/\nObject.myFunction = function() {}",
        "/**\n @method myFunction\n*/\nObject.myFunction = function() {}",
        "/**\n @function myFunction\n*/\nObject.myFunction = function() {}",
        "(function(){})();",

        "var object = {\n/**\n @func myFunction - Some function \n*/\nmyFunction: function() {} }",
        "var object = {\n/**\n @method myFunction - Some function \n*/\nmyFunction: function() {} }",
        "var object = {\n/**\n @function myFunction - Some function \n*/\nmyFunction: function() {} }",

        "var array = [1,2,3];\narray.filter(function() {});",
        "Object.keys(this.options.rules || {}).forEach(function(name) {}.bind(this));",
        "var object = { name: 'key'};\nObject.keys(object).forEach(function() {})",
        {
            code: "function myFunction() {}",
            options: [{
                require: {
                    FunctionDeclaration: false,
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }]
        },
        {
            code: "var myFunction = function() {}",
            options: [{
                require: {
                    FunctionDeclaration: false,
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }]
        },
        {
            code:
                "/**\n" +
                " * Description for A.\n" +
                " */\n" +
                "class A {\n" +
                "    /**\n" +
                "     * Description for constructor.\n" +
                "     * @param {object[]} xs - xs\n" +
                "     */\n" +
                "    constructor(xs) {\n" +
                "        this.a = xs;" +
                "    }\n" +
                "}",
            options: [{
                require: {
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }],
            parserOptions: { ecmaVersion: 6 }
        },
        {
            code:
            "/**\n" +
            " * Description for A.\n" +
            " */\n" +
            "class App extends Component {\n" +
            "    /**\n" +
            "     * Description for constructor.\n" +
            "     * @param {object[]} xs - xs\n" +
            "     */\n" +
            "    constructor(xs) {\n" +
            "        this.a = xs;" +
            "    }\n" +
            "}",
            options: [{
                require: {
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }],
            parserOptions: { ecmaVersion: 6 }
        },
        {
            code:
            "/**\n" +
            " * Description for A.\n" +
            " */\n" +
            "export default class App extends Component {\n" +
            "    /**\n" +
            "     * Description for constructor.\n" +
            "     * @param {object[]} xs - xs\n" +
            "     */\n" +
            "    constructor(xs) {\n" +
            "        this.a = xs;" +
            "    }\n" +
            "}",
            options: [{
                require: {
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }],
            parserOptions: { ecmaVersion: 6, sourceType: "module" }
        },
        {
            code:
            "/**\n" +
            " * Description for A.\n" +
            " */\n" +
            "export class App extends Component {\n" +
            "    /**\n" +
            "     * Description for constructor.\n" +
            "     * @param {object[]} xs - xs\n" +
            "     */\n" +
            "    constructor(xs) {\n" +
            "        this.a = xs;" +
            "    }\n" +
            "}",
            options: [{
                require: {
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }],
            parserOptions: { ecmaVersion: 6, sourceType: "module" }
        },
        {
            code:
            "class A {\n" +
            "    constructor(xs) {\n" +
            "        this.a = xs;" +
            "    }\n" +
            "}",
            options: [{
                require: {
                    MethodDefinition: false,
                    ClassDeclaration: false
                }
            }],
            parserOptions: { ecmaVersion: 6 }
        },
        {
            code: "/**\n Function doing something\n*/\nvar myFunction = () => {}",
            options: [{
                require: {
                    ArrowFunctionExpression: true
                }
            }],
            parserOptions: { ecmaVersion: 6 }
        },
        {
            code: "/**\n Function doing something\n*/\nvar myFunction = () => () => {}",
            options: [{
                require: {
                    ArrowFunctionExpression: true
                }
            }],
            parserOptions: { ecmaVersion: 6 }
        },
        {
            code: "setTimeout(() => {}, 10);",
            options: [{
                require: {
                    ArrowFunctionExpression: true
                }
            }],
            parserOptions: { ecmaVersion: 6 }
        },
        {
            code: "/**\nJSDoc Block\n*/\nvar foo = function() {}",
            options: [{
                require: {
                    FunctionExpression: true
                }
            }]
        },
        {
            code: "const foo = {/**\nJSDoc Block\n*/\nbar() {}}",
            options: [{
                require: {
                    FunctionExpression: true
                }
            }],
            parserOptions: { ecmaVersion: 6 }
        },
        {
            code: "var foo = {/**\nJSDoc Block\n*/\nbar: function() {}}",
            options: [{
                require: {
                    FunctionExpression: true
                }
            }]
        },
        {
            code: " var foo = { [function() {}]: 1 };",
            options: [{
                require: {
                    FunctionExpression: true
                }
            }],
            parserOptions: { ecmaVersion: 6 }
        }
    ],

    invalid: [
        {
            code: "function myFunction() {}",
            errors: [{
                messageId: "missingJSDocComment",
                type: "FunctionDeclaration"
            }]
        },
        {
            code:
                "/**\n" +
                " * Description for A.\n" +
                " */\n" +
                "class A {\n" +
                "    constructor(xs) {\n" +
                "        this.a = xs;" +
                "    }\n" +
                "}",
            options: [{
                require: {
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }],
            parserOptions: { ecmaVersion: 6 },
            errors: [{
                messageId: "missingJSDocComment",
                type: "FunctionExpression"
            }]
        },
        {
            code:
                "class A {\n" +
                "    /**\n" +
                "     * Description for constructor.\n" +
                "     * @param {object[]} xs - xs\n" +
                "     */\n" +
                "    constructor(xs) {\n" +
                "        this.a = xs;" +
                "    }\n" +
                "}",
            options: [{
                require: {
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }],
            parserOptions: { ecmaVersion: 6 },
            errors: [{
                messageId: "missingJSDocComment",
                type: "ClassDeclaration"
            }]
        },
        {
            code:
            "class A extends B {\n" +
            "    /**\n" +
            "     * Description for constructor.\n" +
            "     * @param {object[]} xs - xs\n" +
            "     */\n" +
            "    constructor(xs) {\n" +
            "        this.a = xs;" +
            "    }\n" +
            "}",
            options: [{
                require: {
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }],
            parserOptions: { ecmaVersion: 6 },
            errors: [{
                messageId: "missingJSDocComment",
                type: "ClassDeclaration"
            }]
        },
        {
            code:
            "export class A extends B {\n" +
            "    /**\n" +
            "     * Description for constructor.\n" +
            "     * @param {object[]} xs - xs\n" +
            "     */\n" +
            "    constructor(xs) {\n" +
            "        this.a = xs;" +
            "    }\n" +
            "}",
            options: [{
                require: {
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }],
            parserOptions: { ecmaVersion: 6, sourceType: "module" },
            errors: [{
                messageId: "missingJSDocComment",
                type: "ClassDeclaration"
            }]
        },
        {
            code:
            "export default class A extends B {\n" +
            "    /**\n" +
            "     * Description for constructor.\n" +
            "     * @param {object[]} xs - xs\n" +
            "     */\n" +
            "    constructor(xs) {\n" +
            "        this.a = xs;" +
            "    }\n" +
            "}",
            options: [{
                require: {
                    MethodDefinition: true,
                    ClassDeclaration: true
                }
            }],
            parserOptions: { ecmaVersion: 6, sourceType: "module" },
            errors: [{
                messageId: "missingJSDocComment",
                type: "ClassDeclaration"
            }]
        },
        {
            code: "var myFunction = () => {}",
            options: [{
                require: {
                    ArrowFunctionExpression: true
                }
            }],
            parserOptions: { ecmaVersion: 6 },
            errors: [{
                messageId: "missingJSDocComment",
                type: "ArrowFunctionExpression"
            }]
        },
        {
            code: "var myFunction = () => () => {}",
            options: [{
                require: {
                    ArrowFunctionExpression: true
                }
            }],
            parserOptions: { ecmaVersion: 6 },
            errors: [{
                messageId: "missingJSDocComment",
                type: "ArrowFunctionExpression"
            }]
        },
        {
            code: "var foo = function() {}",
            options: [{
                require: {
                    FunctionExpression: true
                }
            }],
            errors: [{
                messageId: "missingJSDocComment",
                type: "FunctionExpression"
            }]
        },
        {
            code: "const foo = {bar() {}}",
            options: [{
                require: {
                    FunctionExpression: true
                }
            }],
            parserOptions: { ecmaVersion: 6 },
            errors: [{
                messageId: "missingJSDocComment",
                type: "FunctionExpression"
            }]
        },
        {
            code: "var foo = {bar: function() {}}",
            options: [{
                require: {
                    FunctionExpression: true
                }
            }],
            errors: [{
                messageId: "missingJSDocComment",
                type: "FunctionExpression"
            }]
        }
    ]
});
Commit	Line	Data
eb39fafa DC	1	/**
	2	* @fileoverview Test file for require-jsdoc rule
	3	* @author Gyandeep Singh
	4	*/
	5	"use strict";
	6
609c276f TL	7	//------------------------------------------------------------------------------
	8	// Requirements
	9	//------------------------------------------------------------------------------
	10
eb39fafa DC	11	const rule = require("../../../lib/rules/require-jsdoc"),
	12	{ RuleTester } = require("../../../lib/rule-tester");
	13
	14	//------------------------------------------------------------------------------
	15	// Tests
	16	//------------------------------------------------------------------------------
	17
	18	const ruleTester = new RuleTester();
	19
	20	ruleTester.run("require-jsdoc", rule, {
	21	valid: [
	22	"var array = [1,2,3];\narray.forEach(function() {});",
	23	"/*\n @class MyClass \n/\nfunction MyClass() {}",
	24	"/*\n Function doing something\n/\nfunction myFunction() {}",
	25	"/*\n Function doing something\n/\nvar myFunction = function() {};",
	26	"/*\n Function doing something\n/\nObject.myFunction = function () {};",
	27	"var obj = { \n /*\n Function doing something\n/\n myFunction: function () {} };",
	28
	29	"/*\n @func myFunction \n/\nfunction myFunction() {}",
	30	"/*\n @method myFunction\n/\nfunction myFunction() {}",
	31	"/*\n @function myFunction\n/\nfunction myFunction() {}",
	32
	33	"/*\n @func myFunction \n/\nvar myFunction = function () {}",
	34	"/*\n @method myFunction\n/\nvar myFunction = function () {}",
	35	"/*\n @function myFunction\n/\nvar myFunction = function () {}",
	36
	37	"/*\n @func myFunction \n/\nObject.myFunction = function() {}",
	38	"/*\n @method myFunction\n/\nObject.myFunction = function() {}",
	39	"/*\n @function myFunction\n/\nObject.myFunction = function() {}",
	40	"(function(){})();",
	41
	42	"var object = {\n/*\n @func myFunction - Some function \n/\nmyFunction: function() {} }",
	43	"var object = {\n/*\n @method myFunction - Some function \n/\nmyFunction: function() {} }",
	44	"var object = {\n/*\n @function myFunction - Some function \n/\nmyFunction: function() {} }",
	45
	46	"var array = [1,2,3];\narray.filter(function() {});",
	47	"Object.keys(this.options.rules \|\| {}).forEach(function(name) {}.bind(this));",
	48	"var object = { name: 'key'};\nObject.keys(object).forEach(function() {})",
	49	{
	50	code: "function myFunction() {}",
	51	options: [{
	52	require: {
	53	FunctionDeclaration: false,
	54	MethodDefinition: true,
	55	ClassDeclaration: true
	56	}
	57	}]
	58	},
	59	{
	60	code: "var myFunction = function() {}",
	61	options: [{
	62	require: {
	63	FunctionDeclaration: false,
	64	MethodDefinition: true,
	65	ClassDeclaration: true
	66	}
	67	}]
	68	},
	69	{
	70	code:
	71	"/**\n" +
	72	" * Description for A.\n" +
	73	" */\n" +
	74	"class A {\n" +
75	" /**\n" +
76	" * Description for constructor.\n" +
77	" * @param {object[]} xs - xs\n" +
78	" */\n" +
79	" constructor(xs) {\n" +
80	" this.a = xs;" +
81	" }\n" +
82	"}",
83	options: [{
84	require: {
85	MethodDefinition: true,
86	ClassDeclaration: true
87	}
88	}],
89	parserOptions: { ecmaVersion: 6 }
90	},
91	{
92	code:
93	"/**\n" +
94	" * Description for A.\n" +
95	" */\n" +
96	"class App extends Component {\n" +
97	" /**\n" +
98	" * Description for constructor.\n" +
99	" * @param {object[]} xs - xs\n" +
100	" */\n" +
101	" constructor(xs) {\n" +
102	" this.a = xs;" +
103	" }\n" +
104	"}",
105	options: [{
106	require: {
107	MethodDefinition: true,
108	ClassDeclaration: true
109	}
110	}],
111	parserOptions: { ecmaVersion: 6 }
112	},
113	{
114	code:
115	"/**\n" +
116	" * Description for A.\n" +
117	" */\n" +
118	"export default class App extends Component {\n" +
119	" /**\n" +
120	" * Description for constructor.\n" +
121	" * @param {object[]} xs - xs\n" +
122	" */\n" +
123	" constructor(xs) {\n" +
124	" this.a = xs;" +
125	" }\n" +
126	"}",
127	options: [{
128	require: {
129	MethodDefinition: true,
130	ClassDeclaration: true
131	}
132	}],
133	parserOptions: { ecmaVersion: 6, sourceType: "module" }
134	},
135	{
136	code:
137	"/**\n" +
138	" * Description for A.\n" +
139	" */\n" +
140	"export class App extends Component {\n" +
141	" /**\n" +
142	" * Description for constructor.\n" +
143	" * @param {object[]} xs - xs\n" +
144	" */\n" +
145	" constructor(xs) {\n" +
146	" this.a = xs;" +
147	" }\n" +
148	"}",
149	options: [{
150	require: {
151	MethodDefinition: true,
152	ClassDeclaration: true
153	}
154	}],
155	parserOptions: { ecmaVersion: 6, sourceType: "module" }
156	},
157	{
158	code:
159	"class A {\n" +
160	" constructor(xs) {\n" +
161	" this.a = xs;" +
162	" }\n" +
163	"}",
164	options: [{
165	require: {
166	MethodDefinition: false,
167	ClassDeclaration: false
168	}
169	}],
170	parserOptions: { ecmaVersion: 6 }
171	},
172	{
173	code: "/*\n Function doing something\n/\nvar myFunction = () => {}",
174	options: [{
175	require: {
176	ArrowFunctionExpression: true
177	}
178	}],
179	parserOptions: { ecmaVersion: 6 }
180	},
181	{
182	code: "/*\n Function doing something\n/\nvar myFunction = () => () => {}",
183	options: [{
184	require: {
185	ArrowFunctionExpression: true
186	}
187	}],
188	parserOptions: { ecmaVersion: 6 }
189	},
190	{
191	code: "setTimeout(() => {}, 10);",
192	options: [{
193	require: {
194	ArrowFunctionExpression: true
195	}
196	}],
197	parserOptions: { ecmaVersion: 6 }
198	},
199	{
200	code: "/*\nJSDoc Block\n/\nvar foo = function() {}",
201	options: [{
202	require: {
203	FunctionExpression: true
204	}
205	}]
206	},
207	{
208	code: "const foo = {/*\nJSDoc Block\n/\nbar() {}}",
209	options: [{
210	require: {
211	FunctionExpression: true
212	}
213	}],
214	parserOptions: { ecmaVersion: 6 }
215	},
216	{
217	code: "var foo = {/*\nJSDoc Block\n/\nbar: function() {}}",
218	options: [{
219	require: {
220	FunctionExpression: true
221	}
222	}]
223	},
224	{
225	code: " var foo = { [function() {}]: 1 };",
226	options: [{
227	require: {
228	FunctionExpression: true
229	}
230	}],
231	parserOptions: { ecmaVersion: 6 }
232	}
233	],
234
235	invalid: [
236	{
237	code: "function myFunction() {}",
238	errors: [{
239	messageId: "missingJSDocComment",
240	type: "FunctionDeclaration"
241	}]
242	},
243	{
244	code:
245	"/**\n" +
246	" * Description for A.\n" +
247	" */\n" +
248	"class A {\n" +
249	" constructor(xs) {\n" +
250	" this.a = xs;" +
251	" }\n" +
252	"}",
253	options: [{
254	require: {
255	MethodDefinition: true,
256	ClassDeclaration: true
257	}
258	}],
259	parserOptions: { ecmaVersion: 6 },
260	errors: [{
261	messageId: "missingJSDocComment",
262	type: "FunctionExpression"
263	}]
264	},
265	{
266	code:
267	"class A {\n" +
268	" /**\n" +
269	" * Description for constructor.\n" +
270	" * @param {object[]} xs - xs\n" +
271	" */\n" +
272	" constructor(xs) {\n" +
273	" this.a = xs;" +
274	" }\n" +
275	"}",
276	options: [{
277	require: {
278	MethodDefinition: true,
279	ClassDeclaration: true
280	}
281	}],
282	parserOptions: { ecmaVersion: 6 },
283	errors: [{
284	messageId: "missingJSDocComment",
285	type: "ClassDeclaration"
286	}]
287	},
288	{
289	code:
290	"class A extends B {\n" +
291	" /**\n" +
292	" * Description for constructor.\n" +
293	" * @param {object[]} xs - xs\n" +
294	" */\n" +
295	" constructor(xs) {\n" +
296	" this.a = xs;" +
297	" }\n" +
298	"}",
299	options: [{
300	require: {
301	MethodDefinition: true,
302	ClassDeclaration: true
303	}
304	}],
305	parserOptions: { ecmaVersion: 6 },
306	errors: [{
307	messageId: "missingJSDocComment",
308	type: "ClassDeclaration"
309	}]
310	},
311	{
312	code:
313	"export class A extends B {\n" +
314	" /**\n" +
315	" * Description for constructor.\n" +
316	" * @param {object[]} xs - xs\n" +
317	" */\n" +
318	" constructor(xs) {\n" +
319	" this.a = xs;" +
320	" }\n" +
321	"}",
322	options: [{
323	require: {
324	MethodDefinition: true,
325	ClassDeclaration: true
326	}
327	}],
328	parserOptions: { ecmaVersion: 6, sourceType: "module" },
329	errors: [{
330	messageId: "missingJSDocComment",
331	type: "ClassDeclaration"
332	}]
333	},
334	{
335	code:
336	"export default class A extends B {\n" +
337	" /**\n" +
338	" * Description for constructor.\n" +
339	" * @param {object[]} xs - xs\n" +
340	" */\n" +
341	" constructor(xs) {\n" +
342	" this.a = xs;" +
343	" }\n" +
344	"}",
345	options: [{
346	require: {
347	MethodDefinition: true,
348	ClassDeclaration: true
349	}
350	}],
351	parserOptions: { ecmaVersion: 6, sourceType: "module" },
352	errors: [{
353	messageId: "missingJSDocComment",
354	type: "ClassDeclaration"
355	}]
356	},
357	{
358	code: "var myFunction = () => {}",
359	options: [{
360	require: {
361	ArrowFunctionExpression: true
362	}
363	}],
364	parserOptions: { ecmaVersion: 6 },
365	errors: [{
366	messageId: "missingJSDocComment",
367	type: "ArrowFunctionExpression"
368	}]
369	},
370	{
371	code: "var myFunction = () => () => {}",
372	options: [{
373	require: {
374	ArrowFunctionExpression: true
375	}
376	}],
377	parserOptions: { ecmaVersion: 6 },
378	errors: [{
379	messageId: "missingJSDocComment",
380	type: "ArrowFunctionExpression"
381	}]
382	},
383	{
384	code: "var foo = function() {}",
385	options: [{
386	require: {
387	FunctionExpression: true
388	}
389	}],
390	errors: [{
391	messageId: "missingJSDocComment",
392	type: "FunctionExpression"
393	}]
394	},
395	{
396	code: "const foo = {bar() {}}",
397	options: [{
398	require: {
399	FunctionExpression: true
400	}
401	}],
402	parserOptions: { ecmaVersion: 6 },
403	errors: [{
404	messageId: "missingJSDocComment",
405	type: "FunctionExpression"
406	}]
407	},
408	{
409	code: "var foo = {bar: function() {}}",
410	options: [{
411	require: {
412	FunctionExpression: true
413	}
414	}],
415	errors: [{
416	messageId: "missingJSDocComment",
417	type: "FunctionExpression"
418	}]
419	}
420	]
421	});