mirror of
https://github.com/langgenius/dify.git
synced 2026-05-04 09:28:04 +08:00
feat(schedule-trigger): enhance cron parser with mature library and comprehensive testing (#26002)
This commit is contained in:
lyzno1
GitHub
@ -11,6 +11,36 @@ describe('cron-parser', () => {
|
||||
expect(isValidCronExpression('0 0 1,15 * *')).toBe(true)
|
||||
})
|
||||
|
||||
test('validates enhanced dayOfWeek syntax', () => {
|
||||
expect(isValidCronExpression('0 9 * * 7')).toBe(true) // Sunday as 7
|
||||
expect(isValidCronExpression('0 9 * * SUN')).toBe(true) // Sunday abbreviation
|
||||
expect(isValidCronExpression('0 9 * * MON')).toBe(true) // Monday abbreviation
|
||||
expect(isValidCronExpression('0 9 * * MON-FRI')).toBe(true) // Range with abbreviations
|
||||
expect(isValidCronExpression('0 9 * * SUN,WED,FRI')).toBe(true) // List with abbreviations
|
||||
})
|
||||
|
||||
test('validates enhanced month syntax', () => {
|
||||
expect(isValidCronExpression('0 9 1 JAN *')).toBe(true) // January abbreviation
|
||||
expect(isValidCronExpression('0 9 1 DEC *')).toBe(true) // December abbreviation
|
||||
expect(isValidCronExpression('0 9 1 JAN-MAR *')).toBe(true) // Range with abbreviations
|
||||
expect(isValidCronExpression('0 9 1 JAN,JUN,DEC *')).toBe(true) // List with abbreviations
|
||||
})
|
||||
|
||||
test('validates special characters', () => {
|
||||
expect(isValidCronExpression('0 9 ? * 1')).toBe(true) // ? wildcard
|
||||
expect(isValidCronExpression('0 9 L * *')).toBe(true) // Last day of month
|
||||
expect(isValidCronExpression('0 9 * * 1#1')).toBe(true) // First Monday of month
|
||||
expect(isValidCronExpression('0 9 * * 1L')).toBe(true) // Last Monday of month
|
||||
})
|
||||
|
||||
test('validates predefined expressions', () => {
|
||||
expect(isValidCronExpression('@yearly')).toBe(true)
|
||||
expect(isValidCronExpression('@monthly')).toBe(true)
|
||||
expect(isValidCronExpression('@weekly')).toBe(true)
|
||||
expect(isValidCronExpression('@daily')).toBe(true)
|
||||
expect(isValidCronExpression('@hourly')).toBe(true)
|
||||
})
|
||||
|
||||
test('rejects invalid cron expressions', () => {
|
||||
expect(isValidCronExpression('')).toBe(false)
|
||||
expect(isValidCronExpression('15 10 1')).toBe(false) // Not enough fields
|
||||
@ -19,13 +49,18 @@ describe('cron-parser', () => {
|
||||
expect(isValidCronExpression('15 25 1 * *')).toBe(false) // Invalid hour
|
||||
expect(isValidCronExpression('15 10 32 * *')).toBe(false) // Invalid day
|
||||
expect(isValidCronExpression('15 10 1 13 *')).toBe(false) // Invalid month
|
||||
expect(isValidCronExpression('15 10 1 * 7')).toBe(false) // Invalid day of week
|
||||
expect(isValidCronExpression('15 10 1 * 8')).toBe(false) // Invalid day of week
|
||||
expect(isValidCronExpression('15 10 1 INVALID *')).toBe(false) // Invalid month abbreviation
|
||||
expect(isValidCronExpression('15 10 1 * INVALID')).toBe(false) // Invalid day abbreviation
|
||||
expect(isValidCronExpression('@invalid')).toBe(false) // Invalid predefined expression
|
||||
})
|
||||
|
||||
test('handles edge cases', () => {
|
||||
expect(isValidCronExpression(' 15 10 1 * * ')).toBe(true) // Whitespace
|
||||
expect(isValidCronExpression('0 0 29 2 *')).toBe(true) // Feb 29 (valid in leap years)
|
||||
expect(isValidCronExpression('59 23 31 12 6')).toBe(true) // Max values
|
||||
expect(isValidCronExpression('0 0 29 FEB *')).toBe(true) // Feb 29 with month abbreviation
|
||||
expect(isValidCronExpression('59 23 31 DEC SAT')).toBe(true) // Max values with abbreviations
|
||||
})
|
||||
})
|
||||
|
||||
@ -168,6 +203,10 @@ describe('cron-parser', () => {
|
||||
|
||||
expect(result).toHaveLength(5)
|
||||
result.forEach((date) => {
|
||||
// Since we're using UTC timezone in this test, the returned dates should
|
||||
// be in the future relative to the current time
|
||||
// Note: our implementation returns dates in "user timezone representation"
|
||||
// but for UTC, this should match the expected behavior
|
||||
expect(date.getTime()).toBeGreaterThan(Date.now())
|
||||
})
|
||||
|
||||
@ -202,21 +241,269 @@ describe('cron-parser', () => {
|
||||
})
|
||||
})
|
||||
|
||||
describe('enhanced syntax tests', () => {
|
||||
test('handles month abbreviations correctly', () => {
|
||||
const result = parseCronExpression('0 12 1 JAN *') // First day of January at noon
|
||||
|
||||
expect(result).toHaveLength(5)
|
||||
result.forEach((date) => {
|
||||
expect(date.getMonth()).toBe(0) // January
|
||||
expect(date.getDate()).toBe(1)
|
||||
expect(date.getHours()).toBe(12)
|
||||
expect(date.getMinutes()).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
test('handles day abbreviations correctly', () => {
|
||||
const result = parseCronExpression('0 14 * * MON') // Every Monday at 14:00
|
||||
|
||||
expect(result).toHaveLength(5)
|
||||
result.forEach((date) => {
|
||||
expect(date.getDay()).toBe(1) // Monday
|
||||
expect(date.getHours()).toBe(14)
|
||||
expect(date.getMinutes()).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
test('handles Sunday as both 0 and 7', () => {
|
||||
const result0 = parseCronExpression('0 10 * * 0') // Sunday as 0
|
||||
const result7 = parseCronExpression('0 10 * * 7') // Sunday as 7
|
||||
const resultSUN = parseCronExpression('0 10 * * SUN') // Sunday as SUN
|
||||
|
||||
expect(result0).toHaveLength(5)
|
||||
expect(result7).toHaveLength(5)
|
||||
expect(resultSUN).toHaveLength(5)
|
||||
|
||||
// All should return Sundays
|
||||
result0.forEach(date => expect(date.getDay()).toBe(0))
|
||||
result7.forEach(date => expect(date.getDay()).toBe(0))
|
||||
resultSUN.forEach(date => expect(date.getDay()).toBe(0))
|
||||
})
|
||||
|
||||
test('handles question mark wildcard', () => {
|
||||
const resultStar = parseCronExpression('0 9 * * 1') // Using *
|
||||
const resultQuestion = parseCronExpression('0 9 ? * 1') // Using ?
|
||||
|
||||
expect(resultStar).toHaveLength(5)
|
||||
expect(resultQuestion).toHaveLength(5)
|
||||
|
||||
// Both should return Mondays at 9:00
|
||||
resultStar.forEach((date) => {
|
||||
expect(date.getDay()).toBe(1)
|
||||
expect(date.getHours()).toBe(9)
|
||||
})
|
||||
resultQuestion.forEach((date) => {
|
||||
expect(date.getDay()).toBe(1)
|
||||
expect(date.getHours()).toBe(9)
|
||||
})
|
||||
})
|
||||
|
||||
test('handles predefined expressions', () => {
|
||||
const daily = parseCronExpression('@daily')
|
||||
const weekly = parseCronExpression('@weekly')
|
||||
const monthly = parseCronExpression('@monthly')
|
||||
|
||||
expect(daily).toHaveLength(5)
|
||||
expect(weekly).toHaveLength(5)
|
||||
expect(monthly).toHaveLength(5)
|
||||
|
||||
// @daily should be at midnight
|
||||
daily.forEach((date) => {
|
||||
expect(date.getHours()).toBe(0)
|
||||
expect(date.getMinutes()).toBe(0)
|
||||
})
|
||||
|
||||
// @weekly should be on Sundays at midnight
|
||||
weekly.forEach((date) => {
|
||||
expect(date.getDay()).toBe(0) // Sunday
|
||||
expect(date.getHours()).toBe(0)
|
||||
expect(date.getMinutes()).toBe(0)
|
||||
})
|
||||
|
||||
// @monthly should be on the 1st of each month at midnight
|
||||
monthly.forEach((date) => {
|
||||
expect(date.getDate()).toBe(1)
|
||||
expect(date.getHours()).toBe(0)
|
||||
expect(date.getMinutes()).toBe(0)
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('edge cases and error handling', () => {
|
||||
test('handles complex month/day combinations', () => {
|
||||
// Test Feb 29 with month abbreviation
|
||||
const result = parseCronExpression('0 12 29 FEB *')
|
||||
if (result.length > 0) {
|
||||
result.forEach((date) => {
|
||||
expect(date.getMonth()).toBe(1) // February
|
||||
expect(date.getDate()).toBe(29)
|
||||
// Should only occur in leap years
|
||||
const year = date.getFullYear()
|
||||
expect(year % 4).toBe(0)
|
||||
})
|
||||
}
|
||||
})
|
||||
|
||||
test('handles mixed syntax correctly', () => {
|
||||
// Mix of numbers and abbreviations (using only dayOfMonth OR dayOfWeek, not both)
|
||||
// Test 1: Month abbreviations with specific day
|
||||
const result1 = parseCronExpression('30 14 15 JAN,JUN,DEC *')
|
||||
expect(result1.length).toBeGreaterThan(0)
|
||||
result1.forEach((date) => {
|
||||
expect(date.getDate()).toBe(15) // Should be 15th day
|
||||
expect([0, 5, 11]).toContain(date.getMonth()) // Jan, Jun, Dec
|
||||
expect(date.getHours()).toBe(14)
|
||||
expect(date.getMinutes()).toBe(30)
|
||||
})
|
||||
|
||||
// Test 2: Month abbreviations with weekdays
|
||||
const result2 = parseCronExpression('0 9 * JAN-MAR MON-FRI')
|
||||
expect(result2.length).toBeGreaterThan(0)
|
||||
result2.forEach((date) => {
|
||||
// Should be weekday OR in Q1 months
|
||||
const isWeekday = date.getDay() >= 1 && date.getDay() <= 5
|
||||
const isQ1 = [0, 1, 2].includes(date.getMonth())
|
||||
expect(isWeekday || isQ1).toBe(true)
|
||||
expect(date.getHours()).toBe(9)
|
||||
expect(date.getMinutes()).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
test('handles timezone edge cases', () => {
|
||||
// Test with different timezones
|
||||
const utcResult = parseCronExpression('0 12 * * *', 'UTC')
|
||||
const nyResult = parseCronExpression('0 12 * * *', 'America/New_York')
|
||||
const tokyoResult = parseCronExpression('0 12 * * *', 'Asia/Tokyo')
|
||||
|
||||
expect(utcResult).toHaveLength(5)
|
||||
expect(nyResult).toHaveLength(5)
|
||||
expect(tokyoResult).toHaveLength(5)
|
||||
|
||||
// All should be at noon in their respective timezones
|
||||
utcResult.forEach(date => expect(date.getHours()).toBe(12))
|
||||
nyResult.forEach(date => expect(date.getHours()).toBe(12))
|
||||
tokyoResult.forEach(date => expect(date.getHours()).toBe(12))
|
||||
})
|
||||
|
||||
test('timezone compatibility and DST handling', () => {
|
||||
// Test DST boundary scenarios
|
||||
jest.useFakeTimers()
|
||||
|
||||
try {
|
||||
// Test 1: DST spring forward (March 2024) - America/New_York
|
||||
jest.setSystemTime(new Date('2024-03-08T10:00:00Z'))
|
||||
const springDST = parseCronExpression('0 2 * * *', 'America/New_York')
|
||||
expect(springDST).toHaveLength(5)
|
||||
springDST.forEach(date => expect([2, 3]).toContain(date.getHours()))
|
||||
|
||||
// Test 2: DST fall back (November 2024) - America/New_York
|
||||
jest.setSystemTime(new Date('2024-11-01T10:00:00Z'))
|
||||
const fallDST = parseCronExpression('0 1 * * *', 'America/New_York')
|
||||
expect(fallDST).toHaveLength(5)
|
||||
fallDST.forEach(date => expect(date.getHours()).toBe(1))
|
||||
|
||||
// Test 3: Cross-timezone consistency on same UTC moment
|
||||
jest.setSystemTime(new Date('2024-06-15T12:00:00Z'))
|
||||
const utcNoon = parseCronExpression('0 12 * * *', 'UTC')
|
||||
const nycMorning = parseCronExpression('0 8 * * *', 'America/New_York') // 8 AM NYC = 12 PM UTC in summer
|
||||
const tokyoEvening = parseCronExpression('0 21 * * *', 'Asia/Tokyo') // 9 PM Tokyo = 12 PM UTC
|
||||
|
||||
expect(utcNoon).toHaveLength(5)
|
||||
expect(nycMorning).toHaveLength(5)
|
||||
expect(tokyoEvening).toHaveLength(5)
|
||||
|
||||
// Verify timezone consistency - all should represent the same UTC moments
|
||||
const utcTime = utcNoon[0]
|
||||
const nycTime = nycMorning[0]
|
||||
const tokyoTime = tokyoEvening[0]
|
||||
|
||||
expect(utcTime.getHours()).toBe(12)
|
||||
expect(nycTime.getHours()).toBe(8)
|
||||
expect(tokyoTime.getHours()).toBe(21)
|
||||
}
|
||||
finally {
|
||||
jest.useRealTimers()
|
||||
}
|
||||
})
|
||||
|
||||
test('backward compatibility with execution-time-calculator timezone logic', () => {
|
||||
// Simulate the exact usage pattern from execution-time-calculator.ts:47
|
||||
const mockData = {
|
||||
cron_expression: '30 14 * * 1-5', // 2:30 PM weekdays
|
||||
timezone: 'America/New_York',
|
||||
}
|
||||
|
||||
// This is the exact call from execution-time-calculator.ts
|
||||
const results = parseCronExpression(mockData.cron_expression, mockData.timezone)
|
||||
expect(results).toHaveLength(5)
|
||||
|
||||
results.forEach((date) => {
|
||||
// Should be weekdays (1-5)
|
||||
expect(date.getDay()).toBeGreaterThanOrEqual(1)
|
||||
expect(date.getDay()).toBeLessThanOrEqual(5)
|
||||
|
||||
// Should be 2:30 PM in the user's timezone representation
|
||||
expect(date.getHours()).toBe(14)
|
||||
expect(date.getMinutes()).toBe(30)
|
||||
expect(date.getSeconds()).toBe(0)
|
||||
|
||||
// Should be Date objects (not CronDate or other types)
|
||||
expect(date).toBeInstanceOf(Date)
|
||||
|
||||
// Should be in the future (relative to test time)
|
||||
expect(date.getTime()).toBeGreaterThan(Date.now())
|
||||
})
|
||||
})
|
||||
|
||||
test('edge case timezone handling', () => {
|
||||
// Test uncommon but valid timezones
|
||||
const australiaResult = parseCronExpression('0 15 * * *', 'Australia/Sydney')
|
||||
const indiaResult = parseCronExpression('0 9 * * *', 'Asia/Kolkata') // UTC+5:30
|
||||
const alaskaResult = parseCronExpression('0 6 * * *', 'America/Anchorage')
|
||||
|
||||
expect(australiaResult).toHaveLength(5)
|
||||
expect(indiaResult).toHaveLength(5)
|
||||
expect(alaskaResult).toHaveLength(5)
|
||||
|
||||
australiaResult.forEach(date => expect(date.getHours()).toBe(15))
|
||||
indiaResult.forEach(date => expect(date.getHours()).toBe(9))
|
||||
alaskaResult.forEach(date => expect(date.getHours()).toBe(6))
|
||||
|
||||
// Test invalid timezone graceful handling
|
||||
const invalidTzResult = parseCronExpression('0 12 * * *', 'Invalid/Timezone')
|
||||
// Should either return empty array or handle gracefully
|
||||
expect(Array.isArray(invalidTzResult)).toBe(true)
|
||||
})
|
||||
|
||||
test('gracefully handles invalid enhanced syntax', () => {
|
||||
// Invalid but close to valid expressions
|
||||
expect(parseCronExpression('0 12 * JANUARY *')).toEqual([]) // Full month name
|
||||
expect(parseCronExpression('0 12 * * MONDAY')).toEqual([]) // Full day name
|
||||
expect(parseCronExpression('0 12 32 JAN *')).toEqual([]) // Invalid day with valid month
|
||||
expect(parseCronExpression('@invalid')).toEqual([]) // Invalid predefined
|
||||
})
|
||||
})
|
||||
|
||||
describe('performance tests', () => {
|
||||
test('performs well for complex expressions', () => {
|
||||
const start = performance.now()
|
||||
|
||||
// Test multiple complex expressions
|
||||
// Test multiple complex expressions including new syntax
|
||||
const expressions = [
|
||||
'*/5 9-17 * * 1-5', // Every 5 minutes, weekdays, business hours
|
||||
'0 */2 1,15 * *', // Every 2 hours on 1st and 15th
|
||||
'30 14 * * 1,3,5', // Mon, Wed, Fri at 14:30
|
||||
'15,45 8-18 * * 1-5', // 15 and 45 minutes past the hour, weekdays
|
||||
'0 9 * JAN-MAR MON-FRI', // Weekdays in Q1 at 9:00
|
||||
'0 12 ? * SUN', // Sundays at noon using ?
|
||||
'@daily', // Predefined expression
|
||||
'@weekly', // Predefined expression
|
||||
]
|
||||
|
||||
expressions.forEach((expr) => {
|
||||
const result = parseCronExpression(expr)
|
||||
expect(result).toHaveLength(5)
|
||||
expect(result.length).toBeGreaterThan(0)
|
||||
expect(result.length).toBeLessThanOrEqual(5)
|
||||
})
|
||||
|
||||
// Test quarterly expression separately (may return fewer than 5 results)
|
||||
@ -226,8 +513,8 @@ describe('cron-parser', () => {
|
||||
|
||||
const end = performance.now()
|
||||
|
||||
// Should complete within reasonable time (less than 100ms for all expressions)
|
||||
expect(end - start).toBeLessThan(100)
|
||||
// Should complete within reasonable time (less than 150ms for all expressions)
|
||||
expect(end - start).toBeLessThan(150)
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
@ -1,229 +1,84 @@
|
||||
const matchesField = (value: number, pattern: string, min: number, max: number): boolean => {
|
||||
if (pattern === '*') return true
|
||||
import { CronExpressionParser } from 'cron-parser'
|
||||
|
||||
if (pattern.includes(','))
|
||||
return pattern.split(',').some(p => matchesField(value, p.trim(), min, max))
|
||||
// Convert a UTC date from cron-parser to user timezone representation
|
||||
// This ensures consistency with other execution time calculations
|
||||
const convertToUserTimezoneRepresentation = (utcDate: Date, timezone: string): Date => {
|
||||
// Get the time string in the target timezone
|
||||
const userTimeStr = utcDate.toLocaleString('en-CA', {
|
||||
timeZone: timezone,
|
||||
hour12: false,
|
||||
})
|
||||
const [dateStr, timeStr] = userTimeStr.split(', ')
|
||||
const [year, month, day] = dateStr.split('-').map(Number)
|
||||
const [hour, minute, second] = timeStr.split(':').map(Number)
|
||||
|
||||
if (pattern.includes('/')) {
|
||||
const [range, step] = pattern.split('/')
|
||||
const stepValue = Number.parseInt(step, 10)
|
||||
if (Number.isNaN(stepValue)) return false
|
||||
|
||||
if (range === '*') {
|
||||
return value % stepValue === min % stepValue
|
||||
}
|
||||
else {
|
||||
const rangeStart = Number.parseInt(range, 10)
|
||||
if (Number.isNaN(rangeStart)) return false
|
||||
return value >= rangeStart && (value - rangeStart) % stepValue === 0
|
||||
}
|
||||
}
|
||||
|
||||
if (pattern.includes('-')) {
|
||||
const [start, end] = pattern.split('-').map(p => Number.parseInt(p.trim(), 10))
|
||||
if (Number.isNaN(start) || Number.isNaN(end)) return false
|
||||
return value >= start && value <= end
|
||||
}
|
||||
|
||||
const numValue = Number.parseInt(pattern, 10)
|
||||
if (Number.isNaN(numValue)) return false
|
||||
return value === numValue
|
||||
}
|
||||
|
||||
const expandCronField = (field: string, min: number, max: number): number[] => {
|
||||
if (field === '*')
|
||||
return Array.from({ length: max - min + 1 }, (_, i) => min + i)
|
||||
|
||||
if (field.includes(','))
|
||||
return field.split(',').flatMap(p => expandCronField(p.trim(), min, max))
|
||||
|
||||
if (field.includes('/')) {
|
||||
const [range, step] = field.split('/')
|
||||
const stepValue = Number.parseInt(step, 10)
|
||||
if (Number.isNaN(stepValue)) return []
|
||||
|
||||
const baseValues = range === '*' ? [min] : expandCronField(range, min, max)
|
||||
const result: number[] = []
|
||||
|
||||
for (let start = baseValues[0]; start <= max; start += stepValue) {
|
||||
if (start >= min && start <= max)
|
||||
result.push(start)
|
||||
}
|
||||
return result
|
||||
}
|
||||
|
||||
if (field.includes('-')) {
|
||||
const [start, end] = field.split('-').map(p => Number.parseInt(p.trim(), 10))
|
||||
if (Number.isNaN(start) || Number.isNaN(end)) return []
|
||||
|
||||
const result: number[] = []
|
||||
for (let i = start; i <= end && i <= max; i++)
|
||||
if (i >= min) result.push(i)
|
||||
|
||||
return result
|
||||
}
|
||||
|
||||
const numValue = Number.parseInt(field, 10)
|
||||
return !Number.isNaN(numValue) && numValue >= min && numValue <= max ? [numValue] : []
|
||||
}
|
||||
|
||||
const matchesCron = (
|
||||
date: Date,
|
||||
minute: string,
|
||||
hour: string,
|
||||
dayOfMonth: string,
|
||||
month: string,
|
||||
dayOfWeek: string,
|
||||
): boolean => {
|
||||
const currentMinute = date.getMinutes()
|
||||
const currentHour = date.getHours()
|
||||
const currentDay = date.getDate()
|
||||
const currentMonth = date.getMonth() + 1
|
||||
const currentDayOfWeek = date.getDay()
|
||||
|
||||
// Basic time matching
|
||||
if (!matchesField(currentMinute, minute, 0, 59)) return false
|
||||
if (!matchesField(currentHour, hour, 0, 23)) return false
|
||||
if (!matchesField(currentMonth, month, 1, 12)) return false
|
||||
|
||||
// Day matching logic: if both dayOfMonth and dayOfWeek are specified (not *),
|
||||
// the cron should match if EITHER condition is true (OR logic)
|
||||
const dayOfMonthSpecified = dayOfMonth !== '*'
|
||||
const dayOfWeekSpecified = dayOfWeek !== '*'
|
||||
|
||||
if (dayOfMonthSpecified && dayOfWeekSpecified) {
|
||||
// If both are specified, match if either matches
|
||||
return matchesField(currentDay, dayOfMonth, 1, 31)
|
||||
|| matchesField(currentDayOfWeek, dayOfWeek, 0, 6)
|
||||
}
|
||||
else if (dayOfMonthSpecified) {
|
||||
// Only day of month specified
|
||||
return matchesField(currentDay, dayOfMonth, 1, 31)
|
||||
}
|
||||
else if (dayOfWeekSpecified) {
|
||||
// Only day of week specified
|
||||
return matchesField(currentDayOfWeek, dayOfWeek, 0, 6)
|
||||
}
|
||||
else {
|
||||
// Both are *, matches any day
|
||||
return true
|
||||
}
|
||||
// Create a new Date object representing this time as "local" time
|
||||
// This matches the behavior expected by the execution-time-calculator
|
||||
return new Date(year, month - 1, day, hour, minute, second)
|
||||
}
|
||||
|
||||
/**
|
||||
* Parse a cron expression and return the next 5 execution times
|
||||
*
|
||||
* @param cronExpression - Standard 5-field cron expression (minute hour day month dayOfWeek)
|
||||
* @param timezone - IANA timezone identifier (e.g., 'UTC', 'America/New_York')
|
||||
* @returns Array of Date objects representing the next 5 execution times
|
||||
*/
|
||||
export const parseCronExpression = (cronExpression: string, timezone: string = 'UTC'): Date[] => {
|
||||
if (!cronExpression || cronExpression.trim() === '')
|
||||
return []
|
||||
|
||||
const parts = cronExpression.trim().split(/\s+/)
|
||||
if (parts.length !== 5)
|
||||
return []
|
||||
|
||||
const [minute, hour, dayOfMonth, month, dayOfWeek] = parts
|
||||
// Support both 5-field format and predefined expressions
|
||||
if (parts.length !== 5 && !cronExpression.startsWith('@'))
|
||||
return []
|
||||
|
||||
try {
|
||||
const nextTimes: Date[] = []
|
||||
|
||||
// Get user timezone current time - no browser timezone involved
|
||||
const now = new Date()
|
||||
const userTimeStr = now.toLocaleString('en-CA', {
|
||||
timeZone: timezone,
|
||||
hour12: false,
|
||||
// Parse the cron expression with timezone support
|
||||
// Use the actual current time for cron-parser to handle properly
|
||||
const interval = CronExpressionParser.parse(cronExpression, {
|
||||
tz: timezone,
|
||||
})
|
||||
const [dateStr, timeStr] = userTimeStr.split(', ')
|
||||
const [year, monthNum, day] = dateStr.split('-').map(Number)
|
||||
const [nowHour, nowMinute, nowSecond] = timeStr.split(':').map(Number)
|
||||
const userToday = new Date(year, monthNum - 1, day, 0, 0, 0, 0)
|
||||
const userCurrentTime = new Date(year, monthNum - 1, day, nowHour, nowMinute, nowSecond)
|
||||
|
||||
const isMonthlyPattern = dayOfMonth !== '*' && dayOfWeek === '*'
|
||||
const isWeeklyPattern = dayOfMonth === '*' && dayOfWeek !== '*'
|
||||
// Get the next 5 execution times using the take() method
|
||||
const nextCronDates = interval.take(5)
|
||||
|
||||
let searchMonths = 12
|
||||
if (isWeeklyPattern) searchMonths = 3
|
||||
else if (!isMonthlyPattern) searchMonths = 2
|
||||
|
||||
for (let monthOffset = 0; monthOffset < searchMonths && nextTimes.length < 5; monthOffset++) {
|
||||
const checkMonth = new Date(userToday.getFullYear(), userToday.getMonth() + monthOffset, 1)
|
||||
const daysInMonth = new Date(checkMonth.getFullYear(), checkMonth.getMonth() + 1, 0).getDate()
|
||||
|
||||
for (let day = 1; day <= daysInMonth && nextTimes.length < 5; day++) {
|
||||
const checkDate = new Date(checkMonth.getFullYear(), checkMonth.getMonth(), day)
|
||||
|
||||
if (minute !== '*' && hour !== '*') {
|
||||
const minuteValues = expandCronField(minute, 0, 59)
|
||||
const hourValues = expandCronField(hour, 0, 23)
|
||||
|
||||
for (const h of hourValues) {
|
||||
for (const m of minuteValues) {
|
||||
checkDate.setHours(h, m, 0, 0)
|
||||
|
||||
// Only add if execution time is in the future and matches cron pattern
|
||||
if (checkDate > userCurrentTime && matchesCron(checkDate, minute, hour, dayOfMonth, month, dayOfWeek))
|
||||
nextTimes.push(new Date(checkDate))
|
||||
}
|
||||
}
|
||||
}
|
||||
else {
|
||||
for (let h = 0; h < 24 && nextTimes.length < 5; h++) {
|
||||
for (let m = 0; m < 60 && nextTimes.length < 5; m++) {
|
||||
checkDate.setHours(h, m, 0, 0)
|
||||
|
||||
// Only add if execution time is in the future and matches cron pattern
|
||||
if (checkDate > userCurrentTime && matchesCron(checkDate, minute, hour, dayOfMonth, month, dayOfWeek))
|
||||
nextTimes.push(new Date(checkDate))
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return nextTimes.sort((a, b) => a.getTime() - b.getTime()).slice(0, 5)
|
||||
// Convert CronDate objects to Date objects and ensure they represent
|
||||
// the time in user timezone (consistent with execution-time-calculator.ts)
|
||||
return nextCronDates.map((cronDate) => {
|
||||
const utcDate = cronDate.toDate()
|
||||
return convertToUserTimezoneRepresentation(utcDate, timezone)
|
||||
})
|
||||
}
|
||||
catch {
|
||||
// Return empty array if parsing fails
|
||||
return []
|
||||
}
|
||||
}
|
||||
|
||||
const isValidCronField = (field: string, min: number, max: number): boolean => {
|
||||
if (field === '*') return true
|
||||
|
||||
if (field.includes(','))
|
||||
return field.split(',').every(p => isValidCronField(p.trim(), min, max))
|
||||
|
||||
if (field.includes('/')) {
|
||||
const [range, step] = field.split('/')
|
||||
const stepValue = Number.parseInt(step, 10)
|
||||
if (Number.isNaN(stepValue) || stepValue <= 0) return false
|
||||
|
||||
if (range === '*') return true
|
||||
return isValidCronField(range, min, max)
|
||||
}
|
||||
|
||||
if (field.includes('-')) {
|
||||
const [start, end] = field.split('-').map(p => Number.parseInt(p.trim(), 10))
|
||||
if (Number.isNaN(start) || Number.isNaN(end)) return false
|
||||
return start >= min && end <= max && start <= end
|
||||
}
|
||||
|
||||
const numValue = Number.parseInt(field, 10)
|
||||
return !Number.isNaN(numValue) && numValue >= min && numValue <= max
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate a cron expression format and syntax
|
||||
*
|
||||
* @param cronExpression - Standard 5-field cron expression to validate
|
||||
* @returns boolean indicating if the cron expression is valid
|
||||
*/
|
||||
export const isValidCronExpression = (cronExpression: string): boolean => {
|
||||
if (!cronExpression || cronExpression.trim() === '')
|
||||
return false
|
||||
|
||||
const parts = cronExpression.trim().split(/\s+/)
|
||||
if (parts.length !== 5)
|
||||
|
||||
// Support both 5-field format and predefined expressions
|
||||
if (parts.length !== 5 && !cronExpression.startsWith('@'))
|
||||
return false
|
||||
|
||||
const [minute, hour, dayOfMonth, month, dayOfWeek] = parts
|
||||
|
||||
return (
|
||||
isValidCronField(minute, 0, 59)
|
||||
&& isValidCronField(hour, 0, 23)
|
||||
&& isValidCronField(dayOfMonth, 1, 31)
|
||||
&& isValidCronField(month, 1, 12)
|
||||
&& isValidCronField(dayOfWeek, 0, 6)
|
||||
)
|
||||
try {
|
||||
// Use cron-parser to validate the expression
|
||||
CronExpressionParser.parse(cronExpression)
|
||||
return true
|
||||
}
|
||||
catch {
|
||||
return false
|
||||
}
|
||||
}
|
||||
|
||||
@ -140,4 +140,236 @@ describe('execution-time-calculator', () => {
|
||||
expect(() => getNextExecutionTimes(data, 1)).not.toThrow()
|
||||
})
|
||||
})
|
||||
|
||||
describe('timezone handling and cron integration', () => {
|
||||
beforeEach(() => {
|
||||
jest.useFakeTimers()
|
||||
jest.setSystemTime(new Date('2024-01-15T10:00:00Z'))
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
jest.useRealTimers()
|
||||
})
|
||||
|
||||
it('cron mode timezone consistency', () => {
|
||||
// Test the exact integration path with cron-parser
|
||||
const data = createMockData({
|
||||
mode: 'cron',
|
||||
cron_expression: '0 9 * * 1-5', // 9 AM weekdays
|
||||
timezone: 'America/New_York',
|
||||
})
|
||||
|
||||
const result = getNextExecutionTimes(data, 3)
|
||||
|
||||
expect(result.length).toBeGreaterThan(0)
|
||||
result.forEach((date) => {
|
||||
// Should be weekdays
|
||||
expect(date.getDay()).toBeGreaterThanOrEqual(1)
|
||||
expect(date.getDay()).toBeLessThanOrEqual(5)
|
||||
|
||||
// Should be 9 AM in the target timezone representation
|
||||
expect(date.getHours()).toBe(9)
|
||||
expect(date.getMinutes()).toBe(0)
|
||||
|
||||
// Should be Date objects
|
||||
expect(date).toBeInstanceOf(Date)
|
||||
})
|
||||
})
|
||||
|
||||
it('cron mode with enhanced syntax', () => {
|
||||
// Test new cron syntax features work through execution-time-calculator
|
||||
const testCases = [
|
||||
{
|
||||
expression: '@daily',
|
||||
expectedHour: 0,
|
||||
expectedMinute: 0,
|
||||
},
|
||||
{
|
||||
expression: '0 15 * * MON',
|
||||
expectedHour: 15,
|
||||
expectedMinute: 0,
|
||||
},
|
||||
{
|
||||
expression: '30 10 1 JAN *',
|
||||
expectedHour: 10,
|
||||
expectedMinute: 30,
|
||||
},
|
||||
]
|
||||
|
||||
testCases.forEach(({ expression, expectedHour, expectedMinute }) => {
|
||||
const data = createMockData({
|
||||
mode: 'cron',
|
||||
cron_expression: expression,
|
||||
timezone: 'UTC',
|
||||
})
|
||||
|
||||
const result = getNextExecutionTimes(data, 1)
|
||||
|
||||
if (result.length > 0) {
|
||||
expect(result[0].getHours()).toBe(expectedHour)
|
||||
expect(result[0].getMinutes()).toBe(expectedMinute)
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
it('timezone consistency across different modes', () => {
|
||||
const timezone = 'Europe/London'
|
||||
|
||||
// Test visual mode with timezone
|
||||
const visualData = createMockData({
|
||||
mode: 'visual',
|
||||
frequency: 'daily',
|
||||
visual_config: { time: '2:00 PM' },
|
||||
timezone,
|
||||
})
|
||||
|
||||
// Test cron mode with same timezone
|
||||
const cronData = createMockData({
|
||||
mode: 'cron',
|
||||
cron_expression: '0 14 * * *', // 2:00 PM
|
||||
timezone,
|
||||
})
|
||||
|
||||
const visualResult = getNextExecutionTimes(visualData, 1)
|
||||
const cronResult = getNextExecutionTimes(cronData, 1)
|
||||
|
||||
expect(visualResult).toHaveLength(1)
|
||||
expect(cronResult).toHaveLength(1)
|
||||
|
||||
// Both should show 2 PM (14:00) in their timezone representation
|
||||
expect(visualResult[0].getHours()).toBe(14)
|
||||
expect(cronResult[0].getHours()).toBe(14)
|
||||
})
|
||||
|
||||
it('DST boundary handling in cron mode', () => {
|
||||
// Test around DST transition
|
||||
jest.setSystemTime(new Date('2024-03-08T10:00:00Z')) // Before DST in US
|
||||
|
||||
const data = createMockData({
|
||||
mode: 'cron',
|
||||
cron_expression: '0 2 * * *', // 2 AM daily
|
||||
timezone: 'America/New_York',
|
||||
})
|
||||
|
||||
const result = getNextExecutionTimes(data, 5)
|
||||
|
||||
expect(result.length).toBeGreaterThan(0)
|
||||
// During DST spring forward, 2 AM becomes 3 AM
|
||||
// This is correct behavior - the cron-parser library handles DST properly
|
||||
result.forEach((date) => {
|
||||
// Should be either 2 AM (non-DST days) or 3 AM (DST transition day)
|
||||
expect([2, 3]).toContain(date.getHours())
|
||||
expect(date.getMinutes()).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
it('invalid cron expression handling', () => {
|
||||
const data = createMockData({
|
||||
mode: 'cron',
|
||||
cron_expression: '',
|
||||
timezone: 'UTC',
|
||||
})
|
||||
|
||||
const result = getNextExecutionTimes(data, 5)
|
||||
expect(result).toEqual([])
|
||||
|
||||
// Test getNextExecutionTime with invalid cron
|
||||
const timeString = getNextExecutionTime(data)
|
||||
expect(timeString).toBe('--')
|
||||
})
|
||||
|
||||
it('cron vs visual mode consistency check', () => {
|
||||
// Compare equivalent expressions in both modes
|
||||
const cronDaily = createMockData({
|
||||
mode: 'cron',
|
||||
cron_expression: '0 0 * * *', // Daily at midnight
|
||||
timezone: 'UTC',
|
||||
})
|
||||
|
||||
const visualDaily = createMockData({
|
||||
mode: 'visual',
|
||||
frequency: 'daily',
|
||||
visual_config: { time: '12:00 AM' },
|
||||
timezone: 'UTC',
|
||||
})
|
||||
|
||||
const cronResult = getNextExecutionTimes(cronDaily, 1)
|
||||
const visualResult = getNextExecutionTimes(visualDaily, 1)
|
||||
|
||||
if (cronResult.length > 0 && visualResult.length > 0) {
|
||||
expect(cronResult[0].getHours()).toBe(visualResult[0].getHours())
|
||||
expect(cronResult[0].getMinutes()).toBe(visualResult[0].getMinutes())
|
||||
}
|
||||
})
|
||||
})
|
||||
|
||||
describe('weekly and monthly frequency timezone handling', () => {
|
||||
beforeEach(() => {
|
||||
jest.useFakeTimers()
|
||||
jest.setSystemTime(new Date('2024-01-15T10:00:00Z'))
|
||||
})
|
||||
|
||||
afterEach(() => {
|
||||
jest.useRealTimers()
|
||||
})
|
||||
|
||||
it('weekly frequency with timezone', () => {
|
||||
const data = createMockData({
|
||||
frequency: 'weekly',
|
||||
visual_config: {
|
||||
time: '9:00 AM',
|
||||
weekdays: ['mon', 'wed', 'fri'],
|
||||
},
|
||||
timezone: 'Asia/Tokyo',
|
||||
})
|
||||
|
||||
const result = getNextExecutionTimes(data, 3)
|
||||
|
||||
expect(result.length).toBeGreaterThan(0)
|
||||
result.forEach((date) => {
|
||||
expect([1, 3, 5]).toContain(date.getDay()) // Mon, Wed, Fri
|
||||
expect(date.getHours()).toBe(9)
|
||||
expect(date.getMinutes()).toBe(0)
|
||||
})
|
||||
})
|
||||
|
||||
it('monthly frequency with timezone', () => {
|
||||
const data = createMockData({
|
||||
frequency: 'monthly',
|
||||
visual_config: {
|
||||
time: '11:30 AM',
|
||||
monthly_days: [1, 15, 'last'],
|
||||
},
|
||||
timezone: 'America/Los_Angeles',
|
||||
})
|
||||
|
||||
const result = getNextExecutionTimes(data, 3)
|
||||
|
||||
expect(result.length).toBeGreaterThan(0)
|
||||
result.forEach((date) => {
|
||||
expect(date.getHours()).toBe(11)
|
||||
expect(date.getMinutes()).toBe(30)
|
||||
// Should be on specified days (1st, 15th, or last day of month)
|
||||
const day = date.getDate()
|
||||
const lastDay = new Date(date.getFullYear(), date.getMonth() + 1, 0).getDate()
|
||||
expect(day === 1 || day === 15 || day === lastDay).toBe(true)
|
||||
})
|
||||
})
|
||||
|
||||
it('hourly frequency with timezone', () => {
|
||||
const data = createMockData({
|
||||
frequency: 'hourly',
|
||||
visual_config: { on_minute: 45 },
|
||||
timezone: 'Europe/Berlin',
|
||||
})
|
||||
|
||||
const result = getNextExecutionTimes(data, 3)
|
||||
|
||||
expect(result.length).toBeGreaterThan(0)
|
||||
result.forEach((date) => {
|
||||
expect(date.getMinutes()).toBe(45)
|
||||
expect(date.getSeconds()).toBe(0)
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
@ -0,0 +1,349 @@
|
||||
import { isValidCronExpression, parseCronExpression } from './cron-parser'
|
||||
import { getNextExecutionTime, getNextExecutionTimes } from './execution-time-calculator'
|
||||
import type { ScheduleTriggerNodeType } from '../types'
|
||||
|
||||
// Comprehensive integration tests for cron-parser and execution-time-calculator compatibility
|
||||
describe('cron-parser + execution-time-calculator integration', () => {
|
||||
beforeAll(() => {
|
||||
jest.useFakeTimers()
|
||||
jest.setSystemTime(new Date('2024-01-15T10:00:00Z'))
|
||||
})
|
||||
|
||||
afterAll(() => {
|
||||
jest.useRealTimers()
|
||||
})
|
||||
|
||||
const createCronData = (overrides: Partial<ScheduleTriggerNodeType> = {}): ScheduleTriggerNodeType => ({
|
||||
id: 'test-cron',
|
||||
type: 'schedule-trigger',
|
||||
mode: 'cron',
|
||||
frequency: 'daily',
|
||||
timezone: 'UTC',
|
||||
...overrides,
|
||||
})
|
||||
|
||||
describe('backward compatibility validation', () => {
|
||||
it('maintains exact behavior for legacy cron expressions', () => {
|
||||
const legacyExpressions = [
|
||||
'15 10 1 * *', // Monthly 1st at 10:15
|
||||
'0 0 * * 0', // Weekly Sunday midnight
|
||||
'*/5 * * * *', // Every 5 minutes
|
||||
'0 9-17 * * 1-5', // Business hours weekdays
|
||||
'30 14 * * 1', // Monday 14:30
|
||||
'0 0 1,15 * *', // 1st and 15th midnight
|
||||
]
|
||||
|
||||
legacyExpressions.forEach((expression) => {
|
||||
// Test direct cron-parser usage
|
||||
const directResult = parseCronExpression(expression, 'UTC')
|
||||
expect(directResult).toHaveLength(5)
|
||||
expect(isValidCronExpression(expression)).toBe(true)
|
||||
|
||||
// Test through execution-time-calculator
|
||||
const data = createCronData({ cron_expression: expression })
|
||||
const calculatorResult = getNextExecutionTimes(data, 5)
|
||||
|
||||
expect(calculatorResult).toHaveLength(5)
|
||||
|
||||
// Results should be identical
|
||||
directResult.forEach((directDate, index) => {
|
||||
const calcDate = calculatorResult[index]
|
||||
expect(calcDate.getTime()).toBe(directDate.getTime())
|
||||
expect(calcDate.getHours()).toBe(directDate.getHours())
|
||||
expect(calcDate.getMinutes()).toBe(directDate.getMinutes())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
it('validates timezone handling consistency', () => {
|
||||
const timezones = ['UTC', 'America/New_York', 'Asia/Tokyo', 'Europe/London']
|
||||
const expression = '0 12 * * *' // Daily noon
|
||||
|
||||
timezones.forEach((timezone) => {
|
||||
// Direct cron-parser call
|
||||
const directResult = parseCronExpression(expression, timezone)
|
||||
|
||||
// Through execution-time-calculator
|
||||
const data = createCronData({ cron_expression: expression, timezone })
|
||||
const calculatorResult = getNextExecutionTimes(data, 5)
|
||||
|
||||
expect(directResult).toHaveLength(5)
|
||||
expect(calculatorResult).toHaveLength(5)
|
||||
|
||||
// All results should show noon (12:00) in their respective timezone
|
||||
directResult.forEach(date => expect(date.getHours()).toBe(12))
|
||||
calculatorResult.forEach(date => expect(date.getHours()).toBe(12))
|
||||
|
||||
// Cross-validation: results should be identical
|
||||
directResult.forEach((directDate, index) => {
|
||||
expect(calculatorResult[index].getTime()).toBe(directDate.getTime())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
it('error handling consistency', () => {
|
||||
const invalidExpressions = [
|
||||
'', // Empty string
|
||||
' ', // Whitespace only
|
||||
'60 10 1 * *', // Invalid minute
|
||||
'15 25 1 * *', // Invalid hour
|
||||
'15 10 32 * *', // Invalid day
|
||||
'15 10 1 13 *', // Invalid month
|
||||
'15 10 1', // Too few fields
|
||||
'15 10 1 * * *', // Too many fields
|
||||
'invalid expression', // Completely invalid
|
||||
]
|
||||
|
||||
invalidExpressions.forEach((expression) => {
|
||||
// Direct cron-parser calls
|
||||
expect(isValidCronExpression(expression)).toBe(false)
|
||||
expect(parseCronExpression(expression, 'UTC')).toEqual([])
|
||||
|
||||
// Through execution-time-calculator
|
||||
const data = createCronData({ cron_expression: expression })
|
||||
const result = getNextExecutionTimes(data, 5)
|
||||
expect(result).toEqual([])
|
||||
|
||||
// getNextExecutionTime should return '--' for invalid cron
|
||||
const timeString = getNextExecutionTime(data)
|
||||
expect(timeString).toBe('--')
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('enhanced features integration', () => {
|
||||
it('month and day abbreviations work end-to-end', () => {
|
||||
const enhancedExpressions = [
|
||||
{ expr: '0 9 1 JAN *', month: 0, day: 1, hour: 9 }, // January 1st 9 AM
|
||||
{ expr: '0 15 * * MON', weekday: 1, hour: 15 }, // Monday 3 PM
|
||||
{ expr: '30 10 15 JUN,DEC *', month: [5, 11], day: 15, hour: 10, minute: 30 }, // Jun/Dec 15th
|
||||
{ expr: '0 12 * JAN-MAR *', month: [0, 1, 2], hour: 12 }, // Q1 noon
|
||||
]
|
||||
|
||||
enhancedExpressions.forEach(({ expr, month, day, weekday, hour, minute = 0 }) => {
|
||||
// Validate through both paths
|
||||
expect(isValidCronExpression(expr)).toBe(true)
|
||||
|
||||
const directResult = parseCronExpression(expr, 'UTC')
|
||||
const data = createCronData({ cron_expression: expr })
|
||||
const calculatorResult = getNextExecutionTimes(data, 3)
|
||||
|
||||
expect(directResult.length).toBeGreaterThan(0)
|
||||
expect(calculatorResult.length).toBeGreaterThan(0)
|
||||
|
||||
// Validate expected properties
|
||||
const validateDate = (date: Date) => {
|
||||
expect(date.getHours()).toBe(hour)
|
||||
expect(date.getMinutes()).toBe(minute)
|
||||
|
||||
if (month !== undefined) {
|
||||
if (Array.isArray(month))
|
||||
expect(month).toContain(date.getMonth())
|
||||
else
|
||||
expect(date.getMonth()).toBe(month)
|
||||
}
|
||||
|
||||
if (day !== undefined)
|
||||
expect(date.getDate()).toBe(day)
|
||||
|
||||
if (weekday !== undefined)
|
||||
expect(date.getDay()).toBe(weekday)
|
||||
}
|
||||
|
||||
directResult.forEach(validateDate)
|
||||
calculatorResult.forEach(validateDate)
|
||||
})
|
||||
})
|
||||
|
||||
it('predefined expressions work through execution-time-calculator', () => {
|
||||
const predefExpressions = [
|
||||
{ expr: '@daily', hour: 0, minute: 0 },
|
||||
{ expr: '@weekly', hour: 0, minute: 0, weekday: 0 }, // Sunday
|
||||
{ expr: '@monthly', hour: 0, minute: 0, day: 1 }, // 1st of month
|
||||
{ expr: '@yearly', hour: 0, minute: 0, month: 0, day: 1 }, // Jan 1st
|
||||
]
|
||||
|
||||
predefExpressions.forEach(({ expr, hour, minute, weekday, day, month }) => {
|
||||
expect(isValidCronExpression(expr)).toBe(true)
|
||||
|
||||
const data = createCronData({ cron_expression: expr })
|
||||
const result = getNextExecutionTimes(data, 3)
|
||||
|
||||
expect(result.length).toBeGreaterThan(0)
|
||||
|
||||
result.forEach((date) => {
|
||||
expect(date.getHours()).toBe(hour)
|
||||
expect(date.getMinutes()).toBe(minute)
|
||||
|
||||
if (weekday !== undefined) expect(date.getDay()).toBe(weekday)
|
||||
if (day !== undefined) expect(date.getDate()).toBe(day)
|
||||
if (month !== undefined) expect(date.getMonth()).toBe(month)
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
it('special characters integration', () => {
|
||||
const specialExpressions = [
|
||||
'0 9 ? * 1', // ? wildcard for day
|
||||
'0 12 * * 7', // Sunday as 7
|
||||
'0 15 L * *', // Last day of month
|
||||
]
|
||||
|
||||
specialExpressions.forEach((expr) => {
|
||||
// Should validate and parse successfully
|
||||
expect(isValidCronExpression(expr)).toBe(true)
|
||||
|
||||
const directResult = parseCronExpression(expr, 'UTC')
|
||||
const data = createCronData({ cron_expression: expr })
|
||||
const calculatorResult = getNextExecutionTimes(data, 2)
|
||||
|
||||
expect(directResult.length).toBeGreaterThan(0)
|
||||
expect(calculatorResult.length).toBeGreaterThan(0)
|
||||
|
||||
// Results should be consistent
|
||||
expect(calculatorResult[0].getHours()).toBe(directResult[0].getHours())
|
||||
expect(calculatorResult[0].getMinutes()).toBe(directResult[0].getMinutes())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('DST and timezone edge cases', () => {
|
||||
it('handles DST transitions consistently', () => {
|
||||
// Test around DST spring forward (March 2024)
|
||||
jest.setSystemTime(new Date('2024-03-08T10:00:00Z'))
|
||||
|
||||
const expression = '0 2 * * *' // 2 AM daily (problematic during DST)
|
||||
const timezone = 'America/New_York'
|
||||
|
||||
const directResult = parseCronExpression(expression, timezone)
|
||||
const data = createCronData({ cron_expression: expression, timezone })
|
||||
const calculatorResult = getNextExecutionTimes(data, 5)
|
||||
|
||||
expect(directResult.length).toBeGreaterThan(0)
|
||||
expect(calculatorResult.length).toBeGreaterThan(0)
|
||||
|
||||
// Both should handle DST gracefully
|
||||
// During DST spring forward, 2 AM becomes 3 AM - this is correct behavior
|
||||
directResult.forEach(date => expect([2, 3]).toContain(date.getHours()))
|
||||
calculatorResult.forEach(date => expect([2, 3]).toContain(date.getHours()))
|
||||
|
||||
// Results should be identical
|
||||
directResult.forEach((directDate, index) => {
|
||||
expect(calculatorResult[index].getTime()).toBe(directDate.getTime())
|
||||
})
|
||||
})
|
||||
|
||||
it('complex timezone scenarios', () => {
|
||||
const scenarios = [
|
||||
{ tz: 'Asia/Kolkata', expr: '30 14 * * *', expectedHour: 14, expectedMinute: 30 }, // UTC+5:30
|
||||
{ tz: 'Australia/Adelaide', expr: '0 8 * * *', expectedHour: 8, expectedMinute: 0 }, // UTC+9:30/+10:30
|
||||
{ tz: 'Pacific/Kiritimati', expr: '0 12 * * *', expectedHour: 12, expectedMinute: 0 }, // UTC+14
|
||||
]
|
||||
|
||||
scenarios.forEach(({ tz, expr, expectedHour, expectedMinute }) => {
|
||||
const directResult = parseCronExpression(expr, tz)
|
||||
const data = createCronData({ cron_expression: expr, timezone: tz })
|
||||
const calculatorResult = getNextExecutionTimes(data, 2)
|
||||
|
||||
expect(directResult.length).toBeGreaterThan(0)
|
||||
expect(calculatorResult.length).toBeGreaterThan(0)
|
||||
|
||||
// Validate expected time
|
||||
directResult.forEach((date) => {
|
||||
expect(date.getHours()).toBe(expectedHour)
|
||||
expect(date.getMinutes()).toBe(expectedMinute)
|
||||
})
|
||||
|
||||
calculatorResult.forEach((date) => {
|
||||
expect(date.getHours()).toBe(expectedHour)
|
||||
expect(date.getMinutes()).toBe(expectedMinute)
|
||||
})
|
||||
|
||||
// Cross-validate consistency
|
||||
expect(calculatorResult[0].getTime()).toBe(directResult[0].getTime())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('performance and reliability', () => {
|
||||
it('handles high-frequency expressions efficiently', () => {
|
||||
const highFreqExpressions = [
|
||||
'*/1 * * * *', // Every minute
|
||||
'*/5 * * * *', // Every 5 minutes
|
||||
'0,15,30,45 * * * *', // Every 15 minutes
|
||||
]
|
||||
|
||||
highFreqExpressions.forEach((expr) => {
|
||||
const start = performance.now()
|
||||
|
||||
// Test both direct and through calculator
|
||||
const directResult = parseCronExpression(expr, 'UTC')
|
||||
const data = createCronData({ cron_expression: expr })
|
||||
const calculatorResult = getNextExecutionTimes(data, 5)
|
||||
|
||||
const end = performance.now()
|
||||
|
||||
expect(directResult).toHaveLength(5)
|
||||
expect(calculatorResult).toHaveLength(5)
|
||||
expect(end - start).toBeLessThan(100) // Should be fast
|
||||
|
||||
// Results should be consistent
|
||||
directResult.forEach((directDate, index) => {
|
||||
expect(calculatorResult[index].getTime()).toBe(directDate.getTime())
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
it('stress test with complex expressions', () => {
|
||||
const complexExpressions = [
|
||||
'15,45 8-18 1,15 JAN-MAR MON-FRI', // Business hours, specific days, Q1, weekdays
|
||||
'0 */2 ? * SUN#1,SUN#3', // First and third Sunday, every 2 hours
|
||||
'30 9 L * *', // Last day of month, 9:30 AM
|
||||
]
|
||||
|
||||
complexExpressions.forEach((expr) => {
|
||||
if (isValidCronExpression(expr)) {
|
||||
const directResult = parseCronExpression(expr, 'America/New_York')
|
||||
const data = createCronData({
|
||||
cron_expression: expr,
|
||||
timezone: 'America/New_York',
|
||||
})
|
||||
const calculatorResult = getNextExecutionTimes(data, 3)
|
||||
|
||||
expect(directResult.length).toBeGreaterThan(0)
|
||||
expect(calculatorResult.length).toBeGreaterThan(0)
|
||||
|
||||
// Validate consistency where results exist
|
||||
const minLength = Math.min(directResult.length, calculatorResult.length)
|
||||
for (let i = 0; i < minLength; i++)
|
||||
expect(calculatorResult[i].getTime()).toBe(directResult[i].getTime())
|
||||
}
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('format compatibility', () => {
|
||||
it('getNextExecutionTime formatting consistency', () => {
|
||||
const testCases = [
|
||||
{ expr: '0 9 * * *', timezone: 'UTC' },
|
||||
{ expr: '30 14 * * 1-5', timezone: 'America/New_York' },
|
||||
{ expr: '@daily', timezone: 'Asia/Tokyo' },
|
||||
]
|
||||
|
||||
testCases.forEach(({ expr, timezone }) => {
|
||||
const data = createCronData({ cron_expression: expr, timezone })
|
||||
const timeString = getNextExecutionTime(data)
|
||||
|
||||
// Should return a formatted time string, not '--'
|
||||
expect(timeString).not.toBe('--')
|
||||
expect(typeof timeString).toBe('string')
|
||||
expect(timeString.length).toBeGreaterThan(0)
|
||||
|
||||
// Should contain expected format elements
|
||||
expect(timeString).toMatch(/\d+:\d+/) // Time format
|
||||
expect(timeString).toMatch(/AM|PM/) // 12-hour format
|
||||
expect(timeString).toMatch(/\d{4}/) // Year
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
Reference in New Issue
Block a user