16895283675

Committed 12 Aug 2025 12:08AM UTC coverage: 89.256% (-7.8%) from 97.037%

Build # 16895283675

Build Type

Pull #481

github

Committed by

web-flow

Commit Message

Merge 39584aad7 into c76f95e92

Pull Request Pull Request #481: build: using rollout

Run Details

457 of 540 branches covered (84.63%)

Branch coverage included in aggregate %.

4 of 4 new or added lines in 2 files covered. (100.0%)

161 existing lines in 11 files now uncovered.

1595 of 1759 relevant lines covered (90.68%)

37.31 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

86.47

/src/pattern/validation/pattern-validation.ts

import convertExpression from '../convertion/index';

const validationRegex = /^(?:\d+|\*|\*\/\d+)$/;

/**
 * @param {string} expression The Cron-Job expression.
 * @param {number} min The minimum value.
 * @param {number} max The maximum value.
 * @returns {boolean}
 */
function isValidExpression(expression, min, max) {
    const options = expression;

    for (const option of options) {
        const optionAsInt = parseInt(option, 10);

        if (
            (!Number.isNaN(optionAsInt) &&
                (optionAsInt < min || optionAsInt > max)) ||
            !validationRegex.test(option)
        )
            return false;
    }

    return true;
}

/**
 * @param {string} expression The Cron-Job expression.
 * @returns {boolean}
 */
function isInvalidSecond(expression) {
    return !isValidExpression(expression, 0, 59);
}

/**
 * @param {string} expression The Cron-Job expression.
 * @returns {boolean}
 */
function isInvalidMinute(expression) {
    return !isValidExpression(expression, 0, 59);
}

/**
 * @param {string} expression The Cron-Job expression.
 * @returns {boolean}
 */
function isInvalidHour(expression) {
    return !isValidExpression(expression, 0, 23);
}

/**
 * @param {string} expression The Cron-Job expression.
 * @returns {boolean}
 */
function isInvalidDayOfMonth(expression) {
    return !isValidExpression(expression, 1, 31);
}

/**
 * @param {string} expression The Cron-Job expression.
 * @returns {boolean}
 */
function isInvalidMonth(expression) {
    return !isValidExpression(expression, 1, 12);
}

/**
 * @param {string} expression The Cron-Job expression.
 * @returns {boolean}
 */
function isInvalidWeekDay(expression) {
    return !isValidExpression(expression, 0, 7);
}

/**
 * @param {string[]} patterns The Cron-Job expression patterns.
 * @param {string[]} executablePatterns The executable Cron-Job expression
 * patterns.
 * @returns {void}
 */
function validateFields(patterns, executablePatterns) {
    if (isInvalidSecond(executablePatterns[0]))
        throw new Error(`${patterns[0]} is a invalid expression for second`);

    if (isInvalidMinute(executablePatterns[1]))
        throw new Error(`${patterns[1]} is a invalid expression for minute`);

    if (isInvalidHour(executablePatterns[2]))
        throw new Error(`${patterns[2]} is a invalid expression for hour`);

    if (isInvalidDayOfMonth(executablePatterns[3]))
        throw new Error(
            `${patterns[3]} is a invalid expression for day of month`
        );

    if (isInvalidMonth(executablePatterns[4]))
        throw new Error(`${patterns[4]} is a invalid expression for month`);

    if (isInvalidWeekDay(executablePatterns[5]))
        throw new Error(`${patterns[5]} is a invalid expression for week day`);
}

/**
 * Validates a Cron-Job expression pattern.
 *
 * @param {string} pattern The Cron-Job expression pattern.
 * @returns {void}
 */
function validate(pattern) {
    if (typeof pattern !== 'string')
        throw new TypeError('pattern must be a string!');

    const patterns = pattern.split(' ');
    const executablePatterns = convertExpression(pattern);

    if (patterns.length === 5) patterns.unshift('0');

    validateFields(patterns, executablePatterns);
}

export default validate;

1	import convertExpression from '../convertion/index';	1✔
2		1✔
3	const validationRegex = /^(?:\d+\|\\|\\/\d+)$/;	1✔
4		1✔
5	/**	1✔
6	* @param {string} expression The Cron-Job expression.	1✔
7	* @param {number} min The minimum value.	1✔
8	* @param {number} max The maximum value.	1✔
9	* @returns {boolean}	1✔
10	*/	1✔
11	function isValidExpression(expression, min, max) {	7✔
12	const options = expression;	7✔
13		7✔
14	for (const option of options) {	7✔
15	const optionAsInt = parseInt(option, 10);	195✔
16		195✔
17	if (	195✔
18	(!Number.isNaN(optionAsInt) &&	195✔
19	(optionAsInt < min \|\| optionAsInt > max)) \|\|	9✔
20	!validationRegex.test(option)	9✔
21	)	195✔
22	return false;	195✔
23	}	195✔
24		7✔
25	return true;	7✔
26	}	1✔
27		1✔
28	/**	1✔
29	* @param {string} expression The Cron-Job expression.	1✔
30	* @returns {boolean}	1✔
31	*/	1✔
32	function isInvalidSecond(expression) {	2!
UNCOV 33	return !isValidExpression(expression, 0, 59);	✔
UNCOV 34	}	×
UNCOV 35		×
UNCOV 36	/**	×
UNCOV 37	* @param {string} expression The Cron-Job expression.	×
UNCOV 38	* @returns {boolean}	×
UNCOV 39	*/	×
40	function isInvalidMinute(expression) {	1✔
41	return !isValidExpression(expression, 0, 59);	67✔
42	}	67✔
43		67✔
44	/**	67✔
45	* @param {string} expression The Cron-Job expression.	67✔
46	* @returns {boolean}	67✔
47	*/	67✔
48	function isInvalidHour(expression) {	1✔
49	return !isValidExpression(expression, 0, 23);	1✔
50	}	1✔
51		1✔
52	/**	1✔
53	* @param {string} expression The Cron-Job expression.	1✔
54	* @returns {boolean}	1✔
55	*/	1✔
56	function isInvalidDayOfMonth(expression) {	1!
57	return !isValidExpression(expression, 1, 31);	1!
58	}	1✔
UNCOV 59		×
UNCOV 60	/**	×
UNCOV 61	* @param {string} expression The Cron-Job expression.	×
UNCOV 62	* @returns {boolean}	×
UNCOV 63	*/	×
64	function isInvalidMonth(expression) {	1✔
65	return !isValidExpression(expression, 1, 12);	1✔
66	}	1✔
67		1✔
68	/**	1✔
69	* @param {string} expression The Cron-Job expression.	1✔
70	* @returns {boolean}	1✔
71	*/	1✔
72	function isInvalidWeekDay(expression) {	1✔
73	return !isValidExpression(expression, 0, 7);	1✔
74	}	1✔
75		1✔
76	/**	1✔
77	* @param {string[]} patterns The Cron-Job expression patterns.	1✔
78	* @param {string[]} executablePatterns The executable Cron-Job expression	1✔
79	* patterns.	1✔
80	* @returns {void}	1✔
81	*/	1✔
82	function validateFields(patterns, executablePatterns) {	2✔
83	if (isInvalidSecond(executablePatterns[0]))	2✔
84	throw new Error(`${patterns[0]} is a invalid expression for second`);	2✔
85		178✔
86	if (isInvalidMinute(executablePatterns[1]))	178✔
87	throw new Error(`${patterns[1]} is a invalid expression for minute`);	178!
88		3,678✔
89	if (isInvalidHour(executablePatterns[2]))	3,678✔
90	throw new Error(`${patterns[2]} is a invalid expression for hour`);	3,678!
91		3,671✔
92	if (isInvalidDayOfMonth(executablePatterns[3]))	2✔
93	throw new Error(	2!
UNCOV 94	`${patterns[3]} is a invalid expression for day of month`	✔
95	);	33✔
96		33✔
97	if (isInvalidMonth(executablePatterns[4]))	2✔
98	throw new Error(`${patterns[4]} is a invalid expression for month`);	2!
99		32✔
100	if (isInvalidWeekDay(executablePatterns[5]))	32✔
101	throw new Error(`${patterns[5]} is a invalid expression for week day`);	2!
102	}	30✔
103		30✔
104	/**	30✔
105	* Validates a Cron-Job expression pattern.	30✔
106	*	30✔
107	* @param {string} pattern The Cron-Job expression pattern.	30✔
108	* @returns {void}	30✔
109	*/	30✔
110	function validate(pattern) {	2✔
111	if (typeof pattern !== 'string')	26✔
112	throw new TypeError('pattern must be a string!');	26!
113		26✔
114	const patterns = pattern.split(' ');	26✔
115	const executablePatterns = convertExpression(pattern);	26✔
116		26✔
117	if (patterns.length === 5) patterns.unshift('0');	26!
118		26✔
119	validateFields(patterns, executablePatterns);	26✔
120	}	26✔
121		26✔
122	export default validate;	26✔

node-cron / node-cron / 16895283675

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous