Remove assert usage for better compability. Add and update test cases to code that was missing proper test cases

Author: harrisiirak

src/CronExpression.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 import { DateTime } from 'luxon';
 
 import { CronDate, DateMathOp, TimeUnit } from './CronDate';
@@ -117,7 +116,9 @@ export class CronExpression {
 
       // The first character represents the weekday
       const weekday = parseInt(expression.toString().charAt(0), 10) % 7;
-      assert(!Number.isNaN(weekday), `Invalid last weekday of the month expression: ${expression}`);
+      if (Number.isNaN(weekday)) {
+        throw new Error(`Invalid last weekday of the month expression: ${expression}`);
+      }
 
       // Check if the current date matches the last specified weekday of the month
       return currentDate.getDay() === weekday && currentDate.isLastWeekdayOfMonth();
@@ -239,9 +240,7 @@ export class CronExpression {
    */
   includesDate(date: Date | CronDate): boolean {
     const { second, minute, hour, dayOfMonth, month, dayOfWeek } = this.#fields;
-    const dtStr = date.toISOString();
-    assert(dtStr != null, 'Invalid date');
-    const dt = DateTime.fromISO(dtStr, { zone: this.#tz });
+    const dt = DateTime.fromISO(date.toISOString()!, { zone: this.#tz });
     return (
       dayOfMonth.values.includes(<DayOfMonthRange>dt.day) &&
       dayOfWeek.values.includes(<DayOfWeekRange>dt.weekday) &&

src/CronExpressionParser.ts

@@ -1,5 +1,3 @@
-import assert from 'assert';
-
 import { CronFieldCollection } from './CronFieldCollection';
 import { CronDate } from './CronDate';
 import { CronExpression, CronExpressionOptions } from './CronExpression';
@@ -15,7 +13,7 @@ import {
   DayOfWeekRange,
   HourRange,
   MonthRange,
-  ParseRageResponse,
+  ParseRangeResponse,
   SixtyRange,
 } from './fields';
 
@@ -99,10 +97,9 @@ export class CronExpressionParser {
 
     expression = PredefinedExpressions[expression as keyof typeof PredefinedExpressions] || expression;
     const rawFields = CronExpressionParser.#getRawFields(expression, strict);
-    assert(
-      rawFields.dayOfMonth === '*' || rawFields.dayOfWeek === '*' || !strict,
-      'Cannot use both dayOfMonth and dayOfWeek together in strict mode!',
-    );
+    if (!(rawFields.dayOfMonth === '*' || rawFields.dayOfWeek === '*' || !strict)) {
+      throw new Error('Cannot use both dayOfMonth and dayOfWeek together in strict mode!');
+    }
 
     const second = CronExpressionParser.#parseField(
       CronUnit.Second,
@@ -151,11 +148,17 @@ export class CronExpressionParser {
    * @returns {RawCronFields} The raw fields.
    */
   static #getRawFields(expression: string, strict: boolean): RawCronFields {
-    assert(!strict || expression.length, 'Invalid cron expression');
+    if (!(!strict || expression.length)) {
+      throw new Error('Invalid cron expression');
+    }
     expression = expression || '0 * * * * *';
     const atoms = expression.trim().split(/\s+/);
-    assert(!strict || atoms.length === 6, 'Invalid cron expression, expected 6 fields');
-    assert(atoms.length <= 6, 'Invalid cron expression, too many fields');
+    if (!(!strict || atoms.length === 6)) {
+      throw new Error('Invalid cron expression, expected 6 fields');
+    }
+    if (atoms.length > 6) {
+      throw new Error('Invalid cron expression, too many fields');
+    }
     const defaults = ['*', '*', '*', '*', '*', '0'];
     if (atoms.length < defaults.length) {
       atoms.unshift(...defaults.slice(atoms.length));
@@ -178,13 +181,17 @@ export class CronExpressionParser {
       value = value.replace(/[a-z]{3}/gi, (match) => {
         match = match.toLowerCase();
         const replacer = Months[match as keyof typeof Months] || DayOfWeek[match as keyof typeof DayOfWeek];
-        assert(replacer != null, `Validation error, cannot resolve alias "${match}"`);
+        if (!replacer) {
+          throw new Error(`Validation error, cannot resolve alias "${match}"`);
+        }
         return replacer.toString();
       });
     }
 
     // Check for valid characters
-    assert(constraints.validChars.test(value), `Invalid characters, got value: ${value}`);
+    if (!constraints.validChars.test(value)) {
+      throw new Error(`Invalid characters, got value: ${value}`);
+    }
 
     // Replace '*' and '?'
     value = value.replace(/[*?]/g, constraints.min + '-' + constraints.max);
@@ -200,35 +207,30 @@ export class CronExpressionParser {
    */
   static #parseSequence(field: CronUnit, val: string, constraints: CronConstraints): (number | string)[] {
     const stack: (number | string)[] = [];
-
     function handleResult(result: number | string | (number | string)[], constraints: CronConstraints) {
       if (Array.isArray(result)) {
-        result.forEach((value) => {
-          if (!CronExpressionParser.#isValidConstraintChar(constraints, value)) {
-            const v = parseInt(value.toString(), 10);
-            const isValid = v >= constraints.min && v <= constraints.max;
-            assert(
-              isValid,
-              `Constraint error, got value ${value} expected range ${constraints.min}-${constraints.max}`,
-            );
-            stack.push(value);
-          }
-        });
+        stack.push(...result);
       } else {
         if (CronExpressionParser.#isValidConstraintChar(constraints, result)) {
           stack.push(result);
         } else {
           const v = parseInt(result.toString(), 10);
           const isValid = v >= constraints.min && v <= constraints.max;
-          assert(isValid, `Constraint error, got value ${result} expected range ${constraints.min}-${constraints.max}`);
+          if (!isValid) {
+            throw new Error(
+              `Constraint error, got value ${result} expected range ${constraints.min}-${constraints.max}`,
+            );
+          }
           stack.push(field === CronUnit.DayOfWeek ? v % 7 : result);
         }
       }
     }
 
     const atoms = val.split(',');
     atoms.forEach((atom) => {
-      assert(atom.length > 0, 'Invalid list value format');
+      if (!(atom.length > 0)) {
+        throw new Error('Invalid list value format');
+      }
       handleResult(CronExpressionParser.#parseRepeat(field, atom, constraints), constraints);
     });
     return stack;
@@ -242,9 +244,11 @@ export class CronExpressionParser {
    * @private
    * @returns {(number | string)[]} The parsed repeat.
    */
-  static #parseRepeat(field: CronUnit, val: string, constraints: CronConstraints): ParseRageResponse {
+  static #parseRepeat(field: CronUnit, val: string, constraints: CronConstraints): ParseRangeResponse {
     const atoms = val.split('/');
-    assert(atoms.length <= 2, `Invalid repeat: ${val}`);
+    if (atoms.length > 2) {
+      throw new Error(`Invalid repeat: ${val}`);
+    }
     if (atoms.length === 2) {
       if (!isNaN(parseInt(atoms[0], 10))) {
         atoms[0] = `${atoms[0]}-${constraints.max}`;
@@ -266,8 +270,12 @@ export class CronExpressionParser {
    */
   static #validateRange(min: number, max: number, constraints: CronConstraints): void {
     const isValid = !isNaN(min) && !isNaN(max) && min >= constraints.min && max <= constraints.max;
-    assert(isValid, `Constraint error, got range ${min}-${max} expected range ${constraints.min}-${constraints.max}`);
-    assert(min <= max, `Invalid range: ${min}-${max}, min(${min}) > max(${max})`);
+    if (!isValid) {
+      throw new Error(`Constraint error, got range ${min}-${max} expected range ${constraints.min}-${constraints.max}`);
+    }
+    if (min > max) {
+      throw new Error(`Invalid range: ${min}-${max}, min(${min}) > max(${max})`);
+    }
   }
 
   /**
@@ -278,10 +286,9 @@ export class CronExpressionParser {
    * @throws {Error} Throws an error if the repeat interval is invalid.
    */
   static #validateRepeatInterval(repeatInterval: number): void {
-    assert(
-      !isNaN(repeatInterval) && repeatInterval > 0,
-      `Constraint error, cannot repeat at every ${repeatInterval} time.`,
-    );
+    if (!(!isNaN(repeatInterval) && repeatInterval > 0)) {
+      throw new Error(`Constraint error, cannot repeat at every ${repeatInterval} time.`);
+    }
   }
 
   /**
@@ -320,7 +327,7 @@ export class CronExpressionParser {
     val: string,
     repeatInterval: number,
     constraints: CronConstraints,
-  ): ParseRageResponse {
+  ): ParseRangeResponse {
     const atoms: string[] = val.split('-');
     if (atoms.length <= 1) {
       return isNaN(+val) ? val : +val;
@@ -346,14 +353,14 @@ export class CronExpressionParser {
     }
     const nthValue = +atoms[atoms.length - 1];
     const matches = val.match(/([,-/])/);
-    assert(
-      matches === null,
-      `Constraint error, invalid dayOfWeek \`#\` and \`${matches?.[0]}\` special characters are incompatible`,
-    );
-    assert(
-      atoms.length <= 2 && !isNaN(nthValue) && nthValue >= 1 && nthValue <= 5,
-      'Constraint error, invalid dayOfWeek occurrence number (#)',
-    );
+    if (matches !== null) {
+      throw new Error(
+        `Constraint error, invalid dayOfWeek \`#\` and \`${matches?.[0]}\` special characters are incompatible`,
+      );
+    }
+    if (!(atoms.length <= 2 && !isNaN(nthValue) && nthValue >= 1 && nthValue <= 5)) {
+      throw new Error('Constraint error, invalid dayOfWeek occurrence number (#)');
+    }
     return { dayOfWeek: atoms[0], nthDayOfWeek: nthValue };
   }
 

src/CronFieldCollection.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 import {
   CronSecond,
   CronMinute,
@@ -140,18 +139,29 @@ export class CronFieldCollection {
    * console.log(cronFields.dayOfWeek.values); // [1, 2, 3, 4, 5]
    */
   constructor({ second, minute, hour, dayOfMonth, month, dayOfWeek }: CronFields) {
-    assert(second, 'Validation error, Field second is missing');
-    assert(minute, 'Validation error, Field minute is missing');
-    assert(hour, 'Validation error, Field hour is missing');
-    assert(dayOfMonth, 'Validation error, Field dayOfMonth is missing');
-    assert(month, 'Validation error, Field month is missing');
-    assert(dayOfWeek, 'Validation error, Field dayOfWeek is missing');
+    if (!second) {
+      throw new Error('Validation error, Field second is missing');
+    }
+    if (!minute) {
+      throw new Error('Validation error, Field minute is missing');
+    }
+    if (!hour) {
+      throw new Error('Validation error, Field hour is missing');
+    }
+    if (!dayOfMonth) {
+      throw new Error('Validation error, Field dayOfMonth is missing');
+    }
+    if (!month) {
+      throw new Error('Validation error, Field month is missing');
+    }
+    if (!dayOfWeek) {
+      throw new Error('Validation error, Field dayOfWeek is missing');
+    }
 
     if (month.values.length === 1) {
-      assert(
-        parseInt(dayOfMonth.values[0] as string, 10) <= CronMonth.daysInMonth[month.values[0] - 1],
-        'Invalid explicit day of month definition',
-      );
+      if (!(parseInt(dayOfMonth.values[0] as string, 10) <= CronMonth.daysInMonth[month.values[0] - 1])) {
+        throw new Error('Invalid explicit day of month definition');
+      }
     }
 
     this.#second = second;
@@ -332,14 +342,26 @@ export class CronFieldCollection {
     }
 
     const multiplier = range.start === 0 ? range.count - 1 : range.count;
-    assert(step, 'Unexpected range step');
-    assert(range.end, 'Unexpected range end');
+    /* istanbul ignore if */
+    if (!step) {
+      throw new Error('Unexpected range step');
+    }
+    /* istanbul ignore if */
+    if (!range.end) {
+      throw new Error('Unexpected range end');
+    }
     if (step * multiplier > range.end) {
       const mapFn = (_: number, index: number) => {
-        assert(typeof range.start === 'number', 'Unexpected range start');
+        /* istanbul ignore if */
+        if (typeof range.start !== 'number') {
+          throw new Error('Unexpected range start');
+        }
         return index % step === 0 ? range.start + index : null;
       };
-      assert(typeof range.start === 'number', 'Unexpected range start');
+      /* istanbul ignore if */
+      if (typeof range.start !== 'number') {
+        throw new Error('Unexpected range start');
+      }
       const seed = { length: range.end - range.start + 1 };
       return Array.from(seed, mapFn)
         .filter((value) => value !== null)

src/fields/CronField.ts

@@ -1,4 +1,3 @@
-import assert from 'assert';
 import { CronChars, CronConstraints, CronFieldType, CronMax, CronMin } from './types';
 
 export type SerializedCronField = {
@@ -64,8 +63,12 @@ export abstract class CronField {
     values: (number | string)[],
     /* istanbul ignore next - we always pass a value */ wildcard = false,
   ) {
-    assert(Array.isArray(values), `${this.constructor.name} Validation error, values is not an array`);
-    assert(values.length > 0, `${this.constructor.name} Validation error, values contains no values`);
+    if (!Array.isArray(values)) {
+      throw new Error(`${this.constructor.name} Validation error, values is not an array`);
+    }
+    if (!(values.length > 0)) {
+      throw new Error(`${this.constructor.name} Validation error, values contains no values`);
+    }
     this.#values = values.sort(CronField.sorter);
     this.#wildcard = wildcard;
   }
@@ -153,12 +156,15 @@ export abstract class CronField {
       return typeof value === 'number' ? value >= this.min && value <= this.max : this.chars.some(charTest(value));
     };
     const isValidRange = this.#values.every(rangeTest);
-    assert(
-      isValidRange,
-      `${this.constructor.name} Validation error, got value ${badValue} expected range ${this.min}-${this.max}${charsString}`,
-    );
+    if (!isValidRange) {
+      throw new Error(
+        `${this.constructor.name} Validation error, got value ${badValue} expected range ${this.min}-${this.max}${charsString}`,
+      );
+    }
     // check for duplicate value in this.#values array
     const duplicate = this.#values.find((value, index) => this.#values.indexOf(value) !== index);
-    assert(!duplicate, `${this.constructor.name} Validation error, duplicate values found: ${duplicate}`);
+    if (duplicate) {
+      throw new Error(`${this.constructor.name} Validation error, duplicate values found: ${duplicate}`);
+    }
   }
 }

src/fields/types.ts

@@ -14,7 +14,7 @@ export type CronFieldType = SixtyRange[] | HourRange[] | DayOfMonthRange[] | Mon
 export type CronChars = 'L' | 'W';
 export type CronMin = 0 | 1;
 export type CronMax = 7 | 12 | 23 | 31 | 59;
-export type ParseRageResponse = number[] | string[] | number | string;
+export type ParseRangeResponse = number[] | string[] | number | string;
 
 export type CronConstraints = {
   min: CronMin;

tests/CronExpressionParser.test.ts

@@ -17,6 +17,10 @@ describe('CronExpressionParser', () => {
       );
     });
 
+    test('range order is invalid', () => {
+      expect(() => CronExpressionParser.parse('30-20 * * * * *')).toThrow('Invalid range: 30-20, min(30) > max(20)');
+    });
+
     test('invalid range', () => {
       expect(() => CronExpressionParser.parse('- * * * * *')).toThrow(
         'Constraint error, got range NaN-NaN expected range 0-59',
@@ -153,10 +157,19 @@ describe('CronExpressionParser', () => {
       }
     });
 
+    test('both dayOfMonth and dayOfWeek used together in strict mode', () => {
+      const expression = '0 0 12 1-31 * 1';
+      expect(() => CronExpressionParser.parse(expression, { strict: true })).toThrow();
+    });
+
     test('missing fields when in strict mode', () => {
       const expression = '20 15 * *';
       expect(() => CronExpressionParser.parse(expression, { strict: true })).toThrow();
     });
+
+    test('empty expression in strict mode', () => {
+      expect(() => CronExpressionParser.parse('', { strict: true })).toThrow();
+    });
   });
 
   describe('take multiple dates', () => {
@@ -1007,6 +1020,7 @@ describe('CronExpressionParser', () => {
     expect(interval.includesDate(goodDate)).toBe(true);
     expect(interval.includesDate(badDateBefore)).toBe(false);
     expect(interval.includesDate(badDateAfter)).toBe(false);
+    expect(() => interval.includesDate(new Date('invalid'))).toThrow();
   });
 
   test('correctly handle 0 12 1-31 * 1 (#284)', () => {