mirror of https://github.com/langgenius/dify.git
feat(schedule-trigger): enhance cron parser with mature library and comprehensive testing (#26002)
This commit is contained in:
lyzno1
GitHub
parent
4ca14bfdad
commit
034602969f
|
|
@ -14,7 +14,7 @@ def calculate_next_run_at(
|
|||
Calculate the next run time for a cron expression in a specific timezone.
|
||||
|
||||
Args:
|
||||
cron_expression: Cron expression string (supports croniter extensions like 'L')
|
||||
cron_expression: Standard 5-field cron expression or predefined expression
|
||||
timezone: Timezone string (e.g., 'UTC', 'America/New_York')
|
||||
base_time: Base time to calculate from (defaults to current UTC time)
|
||||
|
||||
|
|
@ -22,10 +22,22 @@ def calculate_next_run_at(
|
|||
Next run time in UTC
|
||||
|
||||
Note:
|
||||
Supports croniter's extended syntax including:
|
||||
- 'L' for last day of month
|
||||
- Standard 5-field cron expressions
|
||||
Supports enhanced cron syntax including:
|
||||
- Month abbreviations: JAN, FEB, MAR-JUN, JAN,JUN,DEC
|
||||
- Day abbreviations: MON, TUE, MON-FRI, SUN,WED,FRI
|
||||
- Predefined expressions: @daily, @weekly, @monthly, @yearly, @hourly
|
||||
- Special characters: ? wildcard, L (last day), Sunday as 7
|
||||
- Standard 5-field format only (minute hour day month dayOfWeek)
|
||||
"""
|
||||
# Validate cron expression format to match frontend behavior
|
||||
parts = cron_expression.strip().split()
|
||||
|
||||
# Support both 5-field format and predefined expressions (matching frontend)
|
||||
if len(parts) != 5 and not cron_expression.startswith('@'):
|
||||
raise ValueError(
|
||||
f"Cron expression must have exactly 5 fields or be a predefined expression "
|
||||
f"(@daily, @weekly, etc.). Got {len(parts)} fields: '{cron_expression}'"
|
||||
)
|
||||
|
||||
tz = pytz.timezone(timezone)
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,386 @@
|
|||
"""
|
||||
Enhanced cron syntax compatibility tests for croniter backend.
|
||||
|
||||
This test suite mirrors the frontend cron-parser tests to ensure
|
||||
complete compatibility between frontend and backend cron processing.
|
||||
"""
|
||||
import unittest
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
import pytest
|
||||
import pytz
|
||||
from croniter import CroniterBadCronError
|
||||
|
||||
from libs.schedule_utils import calculate_next_run_at
|
||||
|
||||
|
||||
class TestCronCompatibility(unittest.TestCase):
|
||||
"""Test enhanced cron syntax compatibility with frontend."""
|
||||
|
||||
def setUp(self):
|
||||
"""Set up test environment with fixed time."""
|
||||
self.base_time = datetime(2024, 1, 15, 10, 0, 0, tzinfo=UTC)
|
||||
|
||||
def test_enhanced_dayofweek_syntax(self):
|
||||
"""Test enhanced day-of-week syntax compatibility."""
|
||||
test_cases = [
|
||||
("0 9 * * 7", 0), # Sunday as 7
|
||||
("0 9 * * 0", 0), # Sunday as 0
|
||||
("0 9 * * MON", 1), # Monday abbreviation
|
||||
("0 9 * * TUE", 2), # Tuesday abbreviation
|
||||
("0 9 * * WED", 3), # Wednesday abbreviation
|
||||
("0 9 * * THU", 4), # Thursday abbreviation
|
||||
("0 9 * * FRI", 5), # Friday abbreviation
|
||||
("0 9 * * SAT", 6), # Saturday abbreviation
|
||||
("0 9 * * SUN", 0), # Sunday abbreviation
|
||||
]
|
||||
|
||||
for expr, expected_weekday in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
next_time = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert next_time is not None
|
||||
assert (next_time.weekday() + 1 if next_time.weekday() < 6 else 0) == expected_weekday
|
||||
assert next_time.hour == 9
|
||||
assert next_time.minute == 0
|
||||
|
||||
def test_enhanced_month_syntax(self):
|
||||
"""Test enhanced month syntax compatibility."""
|
||||
test_cases = [
|
||||
("0 9 1 JAN *", 1), # January abbreviation
|
||||
("0 9 1 FEB *", 2), # February abbreviation
|
||||
("0 9 1 MAR *", 3), # March abbreviation
|
||||
("0 9 1 APR *", 4), # April abbreviation
|
||||
("0 9 1 MAY *", 5), # May abbreviation
|
||||
("0 9 1 JUN *", 6), # June abbreviation
|
||||
("0 9 1 JUL *", 7), # July abbreviation
|
||||
("0 9 1 AUG *", 8), # August abbreviation
|
||||
("0 9 1 SEP *", 9), # September abbreviation
|
||||
("0 9 1 OCT *", 10), # October abbreviation
|
||||
("0 9 1 NOV *", 11), # November abbreviation
|
||||
("0 9 1 DEC *", 12), # December abbreviation
|
||||
]
|
||||
|
||||
for expr, expected_month in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
next_time = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert next_time is not None
|
||||
assert next_time.month == expected_month
|
||||
assert next_time.day == 1
|
||||
assert next_time.hour == 9
|
||||
|
||||
def test_predefined_expressions(self):
|
||||
"""Test predefined cron expressions compatibility."""
|
||||
test_cases = [
|
||||
("@yearly", lambda dt: dt.month == 1 and dt.day == 1 and dt.hour == 0),
|
||||
("@annually", lambda dt: dt.month == 1 and dt.day == 1 and dt.hour == 0),
|
||||
("@monthly", lambda dt: dt.day == 1 and dt.hour == 0),
|
||||
("@weekly", lambda dt: dt.weekday() == 6 and dt.hour == 0), # Sunday = 6 in weekday()
|
||||
("@daily", lambda dt: dt.hour == 0 and dt.minute == 0),
|
||||
("@midnight", lambda dt: dt.hour == 0 and dt.minute == 0),
|
||||
("@hourly", lambda dt: dt.minute == 0),
|
||||
]
|
||||
|
||||
for expr, validator in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
next_time = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert next_time is not None
|
||||
assert validator(next_time), f"Validator failed for {expr}: {next_time}"
|
||||
|
||||
def test_special_characters(self):
|
||||
"""Test special characters in cron expressions."""
|
||||
test_cases = [
|
||||
"0 9 ? * 1", # ? wildcard
|
||||
"0 12 * * 7", # Sunday as 7
|
||||
"0 15 L * *", # Last day of month
|
||||
]
|
||||
|
||||
for expr in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
try:
|
||||
next_time = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert next_time is not None
|
||||
assert next_time > self.base_time
|
||||
except Exception as e:
|
||||
self.fail(f"Expression '{expr}' should be valid but raised: {e}")
|
||||
|
||||
def test_range_and_list_syntax(self):
|
||||
"""Test range and list syntax with abbreviations."""
|
||||
test_cases = [
|
||||
"0 9 * * MON-FRI", # Weekday range with abbreviations
|
||||
"0 9 * JAN-MAR *", # Month range with abbreviations
|
||||
"0 9 * * SUN,WED,FRI", # Weekday list with abbreviations
|
||||
"0 9 1 JAN,JUN,DEC *", # Month list with abbreviations
|
||||
]
|
||||
|
||||
for expr in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
try:
|
||||
next_time = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert next_time is not None
|
||||
assert next_time > self.base_time
|
||||
except Exception as e:
|
||||
self.fail(f"Expression '{expr}' should be valid but raised: {e}")
|
||||
|
||||
def test_invalid_enhanced_syntax(self):
|
||||
"""Test that invalid enhanced syntax is properly rejected."""
|
||||
invalid_expressions = [
|
||||
"0 12 * JANUARY *", # Full month name (not supported)
|
||||
"0 12 * * MONDAY", # Full day name (not supported)
|
||||
"0 12 32 JAN *", # Invalid day with valid month
|
||||
"15 10 1 * 8", # Invalid day of week
|
||||
"15 10 1 INVALID *", # Invalid month abbreviation
|
||||
"15 10 1 * INVALID", # Invalid day abbreviation
|
||||
"@invalid", # Invalid predefined expression
|
||||
]
|
||||
|
||||
for expr in invalid_expressions:
|
||||
with self.subTest(expr=expr):
|
||||
with pytest.raises((CroniterBadCronError, ValueError)):
|
||||
calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
|
||||
def test_edge_cases_with_enhanced_syntax(self):
|
||||
"""Test edge cases with enhanced syntax."""
|
||||
test_cases = [
|
||||
("0 0 29 FEB *", lambda dt: dt.month == 2 and dt.day == 29), # Feb 29 with month abbreviation
|
||||
]
|
||||
|
||||
for expr, validator in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
try:
|
||||
next_time = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
if next_time: # Some combinations might not occur soon
|
||||
assert validator(next_time), f"Validator failed for {expr}: {next_time}"
|
||||
except (CroniterBadCronError, ValueError):
|
||||
# Some edge cases might be valid but not have upcoming occurrences
|
||||
pass
|
||||
|
||||
# Test complex expressions that have specific constraints
|
||||
complex_expr = "59 23 31 DEC SAT" # December 31st at 23:59 on Saturday
|
||||
try:
|
||||
next_time = calculate_next_run_at(complex_expr, "UTC", self.base_time)
|
||||
if next_time:
|
||||
# The next occurrence might not be exactly Dec 31 if it's not a Saturday
|
||||
# Just verify it's a valid result
|
||||
assert next_time is not None
|
||||
assert next_time.hour == 23
|
||||
assert next_time.minute == 59
|
||||
except Exception:
|
||||
# Complex date constraints might not have near-future occurrences
|
||||
pass
|
||||
|
||||
|
||||
class TestTimezoneCompatibility(unittest.TestCase):
|
||||
"""Test timezone compatibility between frontend and backend."""
|
||||
|
||||
def setUp(self):
|
||||
"""Set up test environment."""
|
||||
self.base_time = datetime(2024, 1, 15, 10, 0, 0, tzinfo=UTC)
|
||||
|
||||
def test_timezone_consistency(self):
|
||||
"""Test that calculations are consistent across different timezones."""
|
||||
timezones = [
|
||||
"UTC",
|
||||
"America/New_York",
|
||||
"Europe/London",
|
||||
"Asia/Tokyo",
|
||||
"Asia/Kolkata",
|
||||
"Australia/Sydney",
|
||||
]
|
||||
|
||||
expression = "0 12 * * *" # Daily at noon
|
||||
|
||||
for timezone in timezones:
|
||||
with self.subTest(timezone=timezone):
|
||||
next_time = calculate_next_run_at(expression, timezone, self.base_time)
|
||||
assert next_time is not None
|
||||
|
||||
# Convert back to the target timezone to verify it's noon
|
||||
tz = pytz.timezone(timezone)
|
||||
local_time = next_time.astimezone(tz)
|
||||
assert local_time.hour == 12
|
||||
assert local_time.minute == 0
|
||||
|
||||
def test_dst_handling(self):
|
||||
"""Test DST boundary handling."""
|
||||
# Test around DST spring forward (March 2024)
|
||||
dst_base = datetime(2024, 3, 8, 10, 0, 0, tzinfo=UTC)
|
||||
expression = "0 2 * * *" # 2 AM daily (problematic during DST)
|
||||
timezone = "America/New_York"
|
||||
|
||||
try:
|
||||
next_time = calculate_next_run_at(expression, timezone, dst_base)
|
||||
assert next_time is not None
|
||||
|
||||
# During DST spring forward, 2 AM becomes 3 AM - both are acceptable
|
||||
tz = pytz.timezone(timezone)
|
||||
local_time = next_time.astimezone(tz)
|
||||
assert local_time.hour in [2, 3] # Either 2 AM or 3 AM is acceptable
|
||||
except Exception as e:
|
||||
self.fail(f"DST handling failed: {e}")
|
||||
|
||||
def test_half_hour_timezones(self):
|
||||
"""Test timezones with half-hour offsets."""
|
||||
timezones_with_offsets = [
|
||||
("Asia/Kolkata", 17, 30), # UTC+5:30 -> 12:00 UTC = 17:30 IST
|
||||
("Australia/Adelaide", 22, 30), # UTC+10:30 -> 12:00 UTC = 22:30 ACDT (summer time)
|
||||
]
|
||||
|
||||
expression = "0 12 * * *" # Noon UTC
|
||||
|
||||
for timezone, expected_hour, expected_minute in timezones_with_offsets:
|
||||
with self.subTest(timezone=timezone):
|
||||
try:
|
||||
next_time = calculate_next_run_at(expression, timezone, self.base_time)
|
||||
assert next_time is not None
|
||||
|
||||
tz = pytz.timezone(timezone)
|
||||
local_time = next_time.astimezone(tz)
|
||||
assert local_time.hour == expected_hour
|
||||
assert local_time.minute == expected_minute
|
||||
except Exception:
|
||||
# Some complex timezone calculations might vary
|
||||
pass
|
||||
|
||||
def test_invalid_timezone_handling(self):
|
||||
"""Test handling of invalid timezones."""
|
||||
expression = "0 12 * * *"
|
||||
invalid_timezone = "Invalid/Timezone"
|
||||
|
||||
with pytest.raises((ValueError, Exception)): # Should raise an exception
|
||||
calculate_next_run_at(expression, invalid_timezone, self.base_time)
|
||||
|
||||
|
||||
class TestFrontendBackendIntegration(unittest.TestCase):
|
||||
"""Test integration patterns that mirror frontend usage."""
|
||||
|
||||
def setUp(self):
|
||||
"""Set up test environment."""
|
||||
self.base_time = datetime(2024, 1, 15, 10, 0, 0, tzinfo=UTC)
|
||||
|
||||
def test_execution_time_calculator_pattern(self):
|
||||
"""Test the pattern used by execution-time-calculator.ts."""
|
||||
# This mirrors the exact usage from execution-time-calculator.ts:47
|
||||
test_data = {
|
||||
"cron_expression": "30 14 * * 1-5", # 2:30 PM weekdays
|
||||
"timezone": "America/New_York"
|
||||
}
|
||||
|
||||
# Get next 5 execution times (like the frontend does)
|
||||
execution_times = []
|
||||
current_base = self.base_time
|
||||
|
||||
for _ in range(5):
|
||||
next_time = calculate_next_run_at(
|
||||
test_data["cron_expression"],
|
||||
test_data["timezone"],
|
||||
current_base
|
||||
)
|
||||
assert next_time is not None
|
||||
execution_times.append(next_time)
|
||||
current_base = next_time + timedelta(seconds=1) # Move slightly forward
|
||||
|
||||
assert len(execution_times) == 5
|
||||
|
||||
# Validate each execution time
|
||||
for exec_time in execution_times:
|
||||
# Convert to local timezone
|
||||
tz = pytz.timezone(test_data["timezone"])
|
||||
local_time = exec_time.astimezone(tz)
|
||||
|
||||
# Should be weekdays (1-5)
|
||||
assert local_time.weekday() in [0, 1, 2, 3, 4] # Mon-Fri in Python weekday
|
||||
|
||||
# Should be 2:30 PM in local time
|
||||
assert local_time.hour == 14
|
||||
assert local_time.minute == 30
|
||||
assert local_time.second == 0
|
||||
|
||||
def test_schedule_service_integration(self):
|
||||
"""Test integration with ScheduleService patterns."""
|
||||
from core.workflow.nodes.trigger_schedule.entities import VisualConfig
|
||||
from services.schedule_service import ScheduleService
|
||||
|
||||
# Test enhanced syntax through visual config conversion
|
||||
visual_configs = [
|
||||
# Test with month abbreviations
|
||||
{
|
||||
"frequency": "monthly",
|
||||
"config": VisualConfig(time="9:00 AM", monthly_days=[1]),
|
||||
"expected_cron": "0 9 1 * *"
|
||||
},
|
||||
# Test with weekday abbreviations
|
||||
{
|
||||
"frequency": "weekly",
|
||||
"config": VisualConfig(time="2:30 PM", weekdays=["mon", "wed", "fri"]),
|
||||
"expected_cron": "30 14 * * 1,3,5"
|
||||
}
|
||||
]
|
||||
|
||||
for test_case in visual_configs:
|
||||
with self.subTest(frequency=test_case["frequency"]):
|
||||
cron_expr = ScheduleService.visual_to_cron(
|
||||
test_case["frequency"],
|
||||
test_case["config"]
|
||||
)
|
||||
assert cron_expr == test_case["expected_cron"]
|
||||
|
||||
# Verify the generated cron expression is valid
|
||||
next_time = calculate_next_run_at(cron_expr, "UTC", self.base_time)
|
||||
assert next_time is not None
|
||||
|
||||
def test_error_handling_consistency(self):
|
||||
"""Test that error handling matches frontend expectations."""
|
||||
invalid_expressions = [
|
||||
"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 * * *", # 6 fields (not supported in frontend)
|
||||
"0 15 10 1 * * *", # 7 fields (not supported in frontend)
|
||||
"invalid expression", # Completely invalid
|
||||
]
|
||||
|
||||
for expr in invalid_expressions:
|
||||
with self.subTest(expr=repr(expr)):
|
||||
with pytest.raises((CroniterBadCronError, ValueError, Exception)):
|
||||
calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
|
||||
# Note: Empty/whitespace expressions are not tested here as they are
|
||||
# not expected in normal usage due to database constraints (nullable=False)
|
||||
|
||||
def test_performance_requirements(self):
|
||||
"""Test that complex expressions parse within reasonable time."""
|
||||
import time
|
||||
|
||||
complex_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 hour, weekdays
|
||||
"0 9 * JAN-MAR MON-FRI", # Enhanced syntax: Q1 weekdays at 9 AM
|
||||
"0 12 ? * SUN", # Enhanced syntax: Sundays at noon with ?
|
||||
]
|
||||
|
||||
start_time = time.time()
|
||||
|
||||
for expr in complex_expressions:
|
||||
with self.subTest(expr=expr):
|
||||
try:
|
||||
next_time = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert next_time is not None
|
||||
except CroniterBadCronError:
|
||||
# Some enhanced syntax might not be supported, that's OK
|
||||
pass
|
||||
|
||||
end_time = time.time()
|
||||
execution_time = (end_time - start_time) * 1000 # Convert to milliseconds
|
||||
|
||||
# Should complete within reasonable time (less than 150ms like frontend)
|
||||
assert execution_time < 150, "Complex expressions should parse quickly"
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Import timedelta for the test
|
||||
from datetime import timedelta
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,410 @@
|
|||
"""
|
||||
Enhanced schedule_utils tests for new cron syntax support.
|
||||
|
||||
These tests verify that the backend schedule_utils functions properly support
|
||||
the enhanced cron syntax introduced in the frontend, ensuring full compatibility.
|
||||
"""
|
||||
import unittest
|
||||
from datetime import UTC, datetime, timedelta
|
||||
|
||||
import pytest
|
||||
import pytz
|
||||
from croniter import CroniterBadCronError
|
||||
|
||||
from libs.schedule_utils import calculate_next_run_at, convert_12h_to_24h
|
||||
|
||||
|
||||
class TestEnhancedCronSyntax(unittest.TestCase):
|
||||
"""Test enhanced cron syntax in calculate_next_run_at."""
|
||||
|
||||
def setUp(self):
|
||||
"""Set up test with fixed time."""
|
||||
# Monday, January 15, 2024, 10:00 AM UTC
|
||||
self.base_time = datetime(2024, 1, 15, 10, 0, 0, tzinfo=UTC)
|
||||
|
||||
def test_month_abbreviations(self):
|
||||
"""Test month abbreviations (JAN, FEB, etc.)."""
|
||||
test_cases = [
|
||||
("0 12 1 JAN *", 1), # January
|
||||
("0 12 1 FEB *", 2), # February
|
||||
("0 12 1 MAR *", 3), # March
|
||||
("0 12 1 APR *", 4), # April
|
||||
("0 12 1 MAY *", 5), # May
|
||||
("0 12 1 JUN *", 6), # June
|
||||
("0 12 1 JUL *", 7), # July
|
||||
("0 12 1 AUG *", 8), # August
|
||||
("0 12 1 SEP *", 9), # September
|
||||
("0 12 1 OCT *", 10), # October
|
||||
("0 12 1 NOV *", 11), # November
|
||||
("0 12 1 DEC *", 12), # December
|
||||
]
|
||||
|
||||
for expr, expected_month in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
result = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert result is not None, f"Failed to parse: {expr}"
|
||||
assert result.month == expected_month
|
||||
assert result.day == 1
|
||||
assert result.hour == 12
|
||||
assert result.minute == 0
|
||||
|
||||
def test_weekday_abbreviations(self):
|
||||
"""Test weekday abbreviations (SUN, MON, etc.)."""
|
||||
test_cases = [
|
||||
("0 9 * * SUN", 6), # Sunday (weekday() = 6)
|
||||
("0 9 * * MON", 0), # Monday (weekday() = 0)
|
||||
("0 9 * * TUE", 1), # Tuesday
|
||||
("0 9 * * WED", 2), # Wednesday
|
||||
("0 9 * * THU", 3), # Thursday
|
||||
("0 9 * * FRI", 4), # Friday
|
||||
("0 9 * * SAT", 5), # Saturday
|
||||
]
|
||||
|
||||
for expr, expected_weekday in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
result = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert result is not None, f"Failed to parse: {expr}"
|
||||
assert result.weekday() == expected_weekday
|
||||
assert result.hour == 9
|
||||
assert result.minute == 0
|
||||
|
||||
def test_sunday_dual_representation(self):
|
||||
"""Test Sunday as both 0 and 7."""
|
||||
base_time = datetime(2024, 1, 14, 10, 0, 0, tzinfo=UTC) # Sunday
|
||||
|
||||
# Both should give the same next Sunday
|
||||
result_0 = calculate_next_run_at("0 10 * * 0", "UTC", base_time)
|
||||
result_7 = calculate_next_run_at("0 10 * * 7", "UTC", base_time)
|
||||
result_SUN = calculate_next_run_at("0 10 * * SUN", "UTC", base_time)
|
||||
|
||||
assert result_0 is not None
|
||||
assert result_7 is not None
|
||||
assert result_SUN is not None
|
||||
|
||||
# All should be Sundays
|
||||
assert result_0.weekday() == 6 # Sunday = 6 in weekday()
|
||||
assert result_7.weekday() == 6
|
||||
assert result_SUN.weekday() == 6
|
||||
|
||||
# Times should be identical
|
||||
assert result_0 == result_7
|
||||
assert result_0 == result_SUN
|
||||
|
||||
def test_predefined_expressions(self):
|
||||
"""Test predefined expressions (@daily, @weekly, etc.)."""
|
||||
test_cases = [
|
||||
("@yearly", lambda dt: dt.month == 1 and dt.day == 1 and dt.hour == 0 and dt.minute == 0),
|
||||
("@annually", lambda dt: dt.month == 1 and dt.day == 1 and dt.hour == 0 and dt.minute == 0),
|
||||
("@monthly", lambda dt: dt.day == 1 and dt.hour == 0 and dt.minute == 0),
|
||||
("@weekly", lambda dt: dt.weekday() == 6 and dt.hour == 0 and dt.minute == 0), # Sunday
|
||||
("@daily", lambda dt: dt.hour == 0 and dt.minute == 0),
|
||||
("@midnight", lambda dt: dt.hour == 0 and dt.minute == 0),
|
||||
("@hourly", lambda dt: dt.minute == 0),
|
||||
]
|
||||
|
||||
for expr, validator in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
result = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert result is not None, f"Failed to parse: {expr}"
|
||||
assert validator(result), f"Validator failed for {expr}: {result}"
|
||||
|
||||
def test_question_mark_wildcard(self):
|
||||
"""Test ? wildcard character."""
|
||||
# ? in day position with specific weekday
|
||||
result_question = calculate_next_run_at("0 9 ? * 1", "UTC", self.base_time) # Monday
|
||||
result_star = calculate_next_run_at("0 9 * * 1", "UTC", self.base_time) # Monday
|
||||
|
||||
assert result_question is not None
|
||||
assert result_star is not None
|
||||
|
||||
# Both should return Mondays at 9:00
|
||||
assert result_question.weekday() == 0 # Monday
|
||||
assert result_star.weekday() == 0
|
||||
assert result_question.hour == 9
|
||||
assert result_star.hour == 9
|
||||
|
||||
# Results should be identical
|
||||
assert result_question == result_star
|
||||
|
||||
def test_last_day_of_month(self):
|
||||
"""Test 'L' for last day of month."""
|
||||
expr = "0 12 L * *" # Last day of month at noon
|
||||
|
||||
# Test for February (28 days in 2024 - not a leap year check)
|
||||
feb_base = datetime(2024, 2, 15, 10, 0, 0, tzinfo=UTC)
|
||||
result = calculate_next_run_at(expr, "UTC", feb_base)
|
||||
assert result is not None
|
||||
assert result.month == 2
|
||||
assert result.day == 29 # 2024 is a leap year
|
||||
assert result.hour == 12
|
||||
|
||||
def test_range_with_abbreviations(self):
|
||||
"""Test ranges using abbreviations."""
|
||||
test_cases = [
|
||||
"0 9 * * MON-FRI", # Weekday range
|
||||
"0 12 * JAN-MAR *", # Q1 months
|
||||
"0 15 * APR-JUN *", # Q2 months
|
||||
]
|
||||
|
||||
for expr in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
result = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert result is not None, f"Failed to parse range expression: {expr}"
|
||||
assert result > self.base_time
|
||||
|
||||
def test_list_with_abbreviations(self):
|
||||
"""Test lists using abbreviations."""
|
||||
test_cases = [
|
||||
("0 9 * * SUN,WED,FRI", [6, 2, 4]), # Specific weekdays
|
||||
("0 12 1 JAN,JUN,DEC *", [1, 6, 12]), # Specific months
|
||||
]
|
||||
|
||||
for expr, expected_values in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
result = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert result is not None, f"Failed to parse list expression: {expr}"
|
||||
|
||||
if "* *" in expr: # Weekday test
|
||||
assert result.weekday() in expected_values
|
||||
else: # Month test
|
||||
assert result.month in expected_values
|
||||
|
||||
def test_mixed_syntax(self):
|
||||
"""Test mixed traditional and enhanced syntax."""
|
||||
test_cases = [
|
||||
"30 14 15 JAN,JUN,DEC *", # Numbers + month abbreviations
|
||||
"0 9 * JAN-MAR MON-FRI", # Month range + weekday range
|
||||
"45 8 1,15 * MON", # Numbers + weekday abbreviation
|
||||
]
|
||||
|
||||
for expr in test_cases:
|
||||
with self.subTest(expr=expr):
|
||||
result = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert result is not None, f"Failed to parse mixed syntax: {expr}"
|
||||
assert result > self.base_time
|
||||
|
||||
def test_complex_enhanced_expressions(self):
|
||||
"""Test complex expressions with multiple enhanced features."""
|
||||
# Note: Some of these might not be supported by croniter, that's OK
|
||||
complex_expressions = [
|
||||
"0 9 L JAN *", # Last day of January
|
||||
"30 14 * * FRI#1", # First Friday of month (if supported)
|
||||
"0 12 15 JAN-DEC/3 *", # 15th of every 3rd month (quarterly)
|
||||
]
|
||||
|
||||
for expr in complex_expressions:
|
||||
with self.subTest(expr=expr):
|
||||
try:
|
||||
result = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
if result: # If supported, should return valid result
|
||||
assert result > self.base_time
|
||||
except Exception:
|
||||
# Some complex expressions might not be supported - that's acceptable
|
||||
pass
|
||||
|
||||
|
||||
class TestTimezoneHandlingEnhanced(unittest.TestCase):
|
||||
"""Test timezone handling with enhanced syntax."""
|
||||
|
||||
def setUp(self):
|
||||
"""Set up test with fixed time."""
|
||||
self.base_time = datetime(2024, 1, 15, 10, 0, 0, tzinfo=UTC)
|
||||
|
||||
def test_enhanced_syntax_with_timezones(self):
|
||||
"""Test enhanced syntax works correctly across timezones."""
|
||||
timezones = ["UTC", "America/New_York", "Asia/Tokyo", "Europe/London"]
|
||||
expression = "0 12 * * MON" # Monday at noon
|
||||
|
||||
for timezone in timezones:
|
||||
with self.subTest(timezone=timezone):
|
||||
result = calculate_next_run_at(expression, timezone, self.base_time)
|
||||
assert result is not None
|
||||
|
||||
# Convert to local timezone to verify it's Monday at noon
|
||||
tz = pytz.timezone(timezone)
|
||||
local_time = result.astimezone(tz)
|
||||
assert local_time.weekday() == 0 # Monday
|
||||
assert local_time.hour == 12
|
||||
assert local_time.minute == 0
|
||||
|
||||
def test_predefined_expressions_with_timezones(self):
|
||||
"""Test predefined expressions work with different timezones."""
|
||||
expression = "@daily"
|
||||
timezones = ["UTC", "America/New_York", "Asia/Tokyo"]
|
||||
|
||||
for timezone in timezones:
|
||||
with self.subTest(timezone=timezone):
|
||||
result = calculate_next_run_at(expression, timezone, self.base_time)
|
||||
assert result is not None
|
||||
|
||||
# Should be midnight in the specified timezone
|
||||
tz = pytz.timezone(timezone)
|
||||
local_time = result.astimezone(tz)
|
||||
assert local_time.hour == 0
|
||||
assert local_time.minute == 0
|
||||
|
||||
def test_dst_with_enhanced_syntax(self):
|
||||
"""Test DST handling with enhanced syntax."""
|
||||
# DST spring forward date in 2024
|
||||
dst_base = datetime(2024, 3, 8, 10, 0, 0, tzinfo=UTC)
|
||||
expression = "0 2 * * SUN" # Sunday at 2 AM (problematic during DST)
|
||||
timezone = "America/New_York"
|
||||
|
||||
result = calculate_next_run_at(expression, timezone, dst_base)
|
||||
assert result is not None
|
||||
|
||||
# Should handle DST transition gracefully
|
||||
tz = pytz.timezone(timezone)
|
||||
local_time = result.astimezone(tz)
|
||||
assert local_time.weekday() == 6 # Sunday
|
||||
|
||||
# During DST spring forward, 2 AM might become 3 AM
|
||||
assert local_time.hour in [2, 3]
|
||||
|
||||
|
||||
class TestErrorHandlingEnhanced(unittest.TestCase):
|
||||
"""Test error handling for enhanced syntax."""
|
||||
|
||||
def setUp(self):
|
||||
"""Set up test with fixed time."""
|
||||
self.base_time = datetime(2024, 1, 15, 10, 0, 0, tzinfo=UTC)
|
||||
|
||||
def test_invalid_enhanced_syntax(self):
|
||||
"""Test that invalid enhanced syntax raises appropriate errors."""
|
||||
invalid_expressions = [
|
||||
"0 12 * JANUARY *", # Full month name
|
||||
"0 12 * * MONDAY", # Full day name
|
||||
"0 12 32 JAN *", # Invalid day with valid month
|
||||
"0 12 * * MON-SUN-FRI", # Invalid range syntax
|
||||
"0 12 * JAN- *", # Incomplete range
|
||||
"0 12 * * ,MON", # Invalid list syntax
|
||||
"@INVALID", # Invalid predefined
|
||||
]
|
||||
|
||||
for expr in invalid_expressions:
|
||||
with self.subTest(expr=expr):
|
||||
with pytest.raises((CroniterBadCronError, ValueError)):
|
||||
calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
|
||||
def test_boundary_values_with_enhanced_syntax(self):
|
||||
"""Test boundary values work with enhanced syntax."""
|
||||
# Valid boundary expressions
|
||||
valid_expressions = [
|
||||
"0 0 1 JAN *", # Minimum: January 1st midnight
|
||||
"59 23 31 DEC *", # Maximum: December 31st 23:59
|
||||
"0 12 29 FEB *", # Leap year boundary
|
||||
]
|
||||
|
||||
for expr in valid_expressions:
|
||||
with self.subTest(expr=expr):
|
||||
try:
|
||||
result = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
if result: # Some dates might not occur soon
|
||||
assert result > self.base_time
|
||||
except Exception as e:
|
||||
# Some boundary cases might be complex to calculate
|
||||
self.fail(f"Valid boundary expression failed: {expr} - {e}")
|
||||
|
||||
|
||||
class TestPerformanceEnhanced(unittest.TestCase):
|
||||
"""Test performance with enhanced syntax."""
|
||||
|
||||
def setUp(self):
|
||||
"""Set up test with fixed time."""
|
||||
self.base_time = datetime(2024, 1, 15, 10, 0, 0, tzinfo=UTC)
|
||||
|
||||
def test_complex_expression_performance(self):
|
||||
"""Test that complex enhanced expressions parse within reasonable time."""
|
||||
import time
|
||||
|
||||
complex_expressions = [
|
||||
"*/5 9-17 * * MON-FRI", # Every 5 min, weekdays, business hours
|
||||
"0 9 * JAN-MAR MON-FRI", # Q1 weekdays at 9 AM
|
||||
"30 14 1,15 * * ", # 1st and 15th at 14:30
|
||||
"0 12 ? * SUN", # Sundays at noon with ?
|
||||
"@daily", # Predefined expression
|
||||
]
|
||||
|
||||
start_time = time.time()
|
||||
|
||||
for expr in complex_expressions:
|
||||
with self.subTest(expr=expr):
|
||||
try:
|
||||
result = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert result is not None
|
||||
except Exception:
|
||||
# Some expressions might not be supported - acceptable
|
||||
pass
|
||||
|
||||
end_time = time.time()
|
||||
execution_time = (end_time - start_time) * 1000 # milliseconds
|
||||
|
||||
# Should be fast (less than 100ms for all expressions)
|
||||
assert execution_time < 100, "Enhanced expressions should parse quickly"
|
||||
|
||||
def test_multiple_calculations_performance(self):
|
||||
"""Test performance when calculating multiple next times."""
|
||||
import time
|
||||
|
||||
expression = "0 9 * * MON-FRI" # Weekdays at 9 AM
|
||||
iterations = 20
|
||||
|
||||
start_time = time.time()
|
||||
|
||||
current_time = self.base_time
|
||||
for _ in range(iterations):
|
||||
result = calculate_next_run_at(expression, "UTC", current_time)
|
||||
assert result is not None
|
||||
current_time = result + timedelta(seconds=1) # Move forward slightly
|
||||
|
||||
end_time = time.time()
|
||||
total_time = (end_time - start_time) * 1000 # milliseconds
|
||||
avg_time = total_time / iterations
|
||||
|
||||
# Average should be very fast (less than 5ms per calculation)
|
||||
assert avg_time < 5, f"Average calculation time too slow: {avg_time}ms"
|
||||
|
||||
|
||||
class TestRegressionEnhanced(unittest.TestCase):
|
||||
"""Regression tests to ensure enhanced syntax doesn't break existing functionality."""
|
||||
|
||||
def setUp(self):
|
||||
"""Set up test with fixed time."""
|
||||
self.base_time = datetime(2024, 1, 15, 10, 0, 0, tzinfo=UTC)
|
||||
|
||||
def test_traditional_syntax_still_works(self):
|
||||
"""Ensure traditional cron syntax continues to work."""
|
||||
traditional_expressions = [
|
||||
"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
|
||||
]
|
||||
|
||||
for expr in traditional_expressions:
|
||||
with self.subTest(expr=expr):
|
||||
result = calculate_next_run_at(expr, "UTC", self.base_time)
|
||||
assert result is not None, f"Traditional expression failed: {expr}"
|
||||
assert result > self.base_time
|
||||
|
||||
def test_convert_12h_to_24h_unchanged(self):
|
||||
"""Ensure convert_12h_to_24h function is unchanged."""
|
||||
test_cases = [
|
||||
("12:00 AM", (0, 0)), # Midnight
|
||||
("12:00 PM", (12, 0)), # Noon
|
||||
("1:30 AM", (1, 30)), # Early morning
|
||||
("11:45 PM", (23, 45)), # Late evening
|
||||
("6:15 AM", (6, 15)), # Morning
|
||||
("3:30 PM", (15, 30)), # Afternoon
|
||||
]
|
||||
|
||||
for time_str, expected in test_cases:
|
||||
with self.subTest(time_str=time_str):
|
||||
result = convert_12h_to_24h(time_str)
|
||||
assert result == expected, f"12h conversion failed: {time_str}"
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
unittest.main()
|
||||
|
|
@ -0,0 +1,247 @@
|
|||
import nodeDefault from '../default'
|
||||
import type { ScheduleTriggerNodeType } from '../types'
|
||||
|
||||
// Mock translation function
|
||||
const mockT = (key: string, params?: any) => {
|
||||
if (key.includes('fieldRequired')) return `${params?.field} is required`
|
||||
if (key.includes('invalidCronExpression')) return 'Invalid cron expression'
|
||||
if (key.includes('invalidTimezone')) return 'Invalid timezone'
|
||||
if (key.includes('noValidExecutionTime')) return 'No valid execution time'
|
||||
if (key.includes('executionTimeCalculationError')) return 'Execution time calculation error'
|
||||
return key
|
||||
}
|
||||
|
||||
describe('Schedule Trigger Default - Backward Compatibility', () => {
|
||||
describe('Enhanced Cron Expression Support', () => {
|
||||
it('should accept enhanced month abbreviations', () => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone: 'UTC',
|
||||
cron_expression: '0 9 1 JAN *', // January 1st at 9 AM
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(true)
|
||||
expect(result.errorMessage).toBe('')
|
||||
})
|
||||
|
||||
it('should accept enhanced day abbreviations', () => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone: 'UTC',
|
||||
cron_expression: '0 15 * * MON', // Every Monday at 3 PM
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(true)
|
||||
expect(result.errorMessage).toBe('')
|
||||
})
|
||||
|
||||
it('should accept predefined expressions', () => {
|
||||
const predefinedExpressions = ['@daily', '@weekly', '@monthly', '@yearly', '@hourly']
|
||||
|
||||
predefinedExpressions.forEach((expr) => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone: 'UTC',
|
||||
cron_expression: expr,
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(true)
|
||||
expect(result.errorMessage).toBe('')
|
||||
})
|
||||
})
|
||||
|
||||
it('should accept special characters', () => {
|
||||
const specialExpressions = [
|
||||
'0 9 ? * 1', // ? wildcard
|
||||
'0 12 * * 7', // Sunday as 7
|
||||
'0 15 L * *', // Last day of month
|
||||
]
|
||||
|
||||
specialExpressions.forEach((expr) => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone: 'UTC',
|
||||
cron_expression: expr,
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(true)
|
||||
expect(result.errorMessage).toBe('')
|
||||
})
|
||||
})
|
||||
|
||||
it('should maintain backward compatibility with legacy 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((expr) => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone: 'UTC',
|
||||
cron_expression: expr,
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(true)
|
||||
expect(result.errorMessage).toBe('')
|
||||
})
|
||||
})
|
||||
})
|
||||
|
||||
describe('Error Detection and Validation', () => {
|
||||
it('should detect invalid enhanced syntax', () => {
|
||||
const invalidExpressions = [
|
||||
'0 12 * JANUARY *', // Full month name not supported
|
||||
'0 12 * * MONDAY', // Full day name not supported
|
||||
'0 12 32 JAN *', // Invalid day with month abbreviation
|
||||
'@invalid', // Invalid predefined expression
|
||||
'0 12 1 INVALID *', // Invalid month abbreviation
|
||||
'0 12 * * INVALID', // Invalid day abbreviation
|
||||
]
|
||||
|
||||
invalidExpressions.forEach((expr) => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone: 'UTC',
|
||||
cron_expression: expr,
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(false)
|
||||
expect(result.errorMessage).toContain('Invalid cron expression')
|
||||
})
|
||||
})
|
||||
|
||||
it('should handle execution time calculation errors gracefully', () => {
|
||||
// Test with an expression that contains invalid date (Feb 30th)
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone: 'UTC',
|
||||
cron_expression: '0 0 30 2 *', // Feb 30th (invalid date)
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
// Should be an invalid expression error since cron-parser detects Feb 30th as invalid
|
||||
expect(result.isValid).toBe(false)
|
||||
expect(result.errorMessage).toBe('Invalid cron expression')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Timezone Integration', () => {
|
||||
it('should validate with various timezones', () => {
|
||||
const timezones = ['UTC', 'America/New_York', 'Asia/Tokyo', 'Europe/London']
|
||||
|
||||
timezones.forEach((timezone) => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone,
|
||||
cron_expression: '0 12 * * *', // Daily noon
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(true)
|
||||
expect(result.errorMessage).toBe('')
|
||||
})
|
||||
})
|
||||
|
||||
it('should reject invalid timezones', () => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone: 'Invalid/Timezone',
|
||||
cron_expression: '0 12 * * *',
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(false)
|
||||
expect(result.errorMessage).toContain('Invalid timezone')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Visual Mode Compatibility', () => {
|
||||
it('should maintain visual mode validation', () => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'visual',
|
||||
timezone: 'UTC',
|
||||
frequency: 'daily',
|
||||
visual_config: {
|
||||
time: '9:00 AM',
|
||||
},
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(true)
|
||||
expect(result.errorMessage).toBe('')
|
||||
})
|
||||
|
||||
it('should validate weekly configuration', () => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'visual',
|
||||
timezone: 'UTC',
|
||||
frequency: 'weekly',
|
||||
visual_config: {
|
||||
time: '2:30 PM',
|
||||
weekdays: ['mon', 'wed', 'fri'],
|
||||
},
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(true)
|
||||
expect(result.errorMessage).toBe('')
|
||||
})
|
||||
|
||||
it('should validate monthly configuration', () => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'visual',
|
||||
timezone: 'UTC',
|
||||
frequency: 'monthly',
|
||||
visual_config: {
|
||||
time: '11:30 AM',
|
||||
monthly_days: [1, 15, 'last'],
|
||||
},
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(true)
|
||||
expect(result.errorMessage).toBe('')
|
||||
})
|
||||
})
|
||||
|
||||
describe('Edge Cases and Robustness', () => {
|
||||
it('should handle empty/whitespace cron expressions', () => {
|
||||
const emptyExpressions = ['', ' ', '\t\n ']
|
||||
|
||||
emptyExpressions.forEach((expr) => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone: 'UTC',
|
||||
cron_expression: expr,
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(false)
|
||||
expect(result.errorMessage).toMatch(/(Invalid cron expression|required)/)
|
||||
})
|
||||
})
|
||||
|
||||
it('should validate whitespace-padded expressions', () => {
|
||||
const payload: ScheduleTriggerNodeType = {
|
||||
mode: 'cron',
|
||||
timezone: 'UTC',
|
||||
cron_expression: ' 0 12 * * * ', // Padded with whitespace
|
||||
}
|
||||
|
||||
const result = nodeDefault.checkValid(payload, mockT)
|
||||
expect(result.isValid).toBe(true)
|
||||
expect(result.errorMessage).toBe('')
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
@ -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
|
||||
})
|
||||
})
|
||||
})
|
||||
})
|
||||
|
|
@ -76,6 +76,7 @@
|
|||
"classnames": "^2.5.1",
|
||||
"cmdk": "^1.1.1",
|
||||
"copy-to-clipboard": "^3.3.3",
|
||||
"cron-parser": "^5.4.0",
|
||||
"crypto-js": "^4.2.0",
|
||||
"dayjs": "^1.11.13",
|
||||
"decimal.js": "^10.4.3",
|
||||
|
|
|
|||
|
|
@ -147,6 +147,9 @@ importers:
|
|||
copy-to-clipboard:
|
||||
specifier: ^3.3.3
|
||||
version: 3.3.3
|
||||
cron-parser:
|
||||
specifier: ^5.4.0
|
||||
version: 5.4.0
|
||||
crypto-js:
|
||||
specifier: ^4.2.0
|
||||
version: 4.2.0
|
||||
|
|
@ -1721,170 +1724,144 @@ packages:
|
|||
resolution: {integrity: sha512-9B+taZ8DlyyqzZQnoeIvDVR/2F4EbMepXMc/NdVbkzsJbzkUjhXv/70GQJ7tdLA4YJgNP25zukcxpX2/SueNrA==}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-libvips-linux-arm64@1.2.0':
|
||||
resolution: {integrity: sha512-RXwd0CgG+uPRX5YYrkzKyalt2OJYRiJQ8ED/fi1tq9WQW2jsQIn0tqrlR5l5dr/rjqq6AHAxURhj2DVjyQWSOA==}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-libvips-linux-arm@1.0.5':
|
||||
resolution: {integrity: sha512-gvcC4ACAOPRNATg/ov8/MnbxFDJqf/pDePbBnuBDcjsI8PssmjoKMAz4LtLaVi+OnSb5FK/yIOamqDwGmXW32g==}
|
||||
cpu: [arm]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-libvips-linux-arm@1.2.0':
|
||||
resolution: {integrity: sha512-mWd2uWvDtL/nvIzThLq3fr2nnGfyr/XMXlq8ZJ9WMR6PXijHlC3ksp0IpuhK6bougvQrchUAfzRLnbsen0Cqvw==}
|
||||
cpu: [arm]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-libvips-linux-ppc64@1.2.0':
|
||||
resolution: {integrity: sha512-Xod/7KaDDHkYu2phxxfeEPXfVXFKx70EAFZ0qyUdOjCcxbjqyJOEUpDe6RIyaunGxT34Anf9ue/wuWOqBW2WcQ==}
|
||||
cpu: [ppc64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-libvips-linux-s390x@1.0.4':
|
||||
resolution: {integrity: sha512-u7Wz6ntiSSgGSGcjZ55im6uvTrOxSIS8/dgoVMoiGE9I6JAfU50yH5BoDlYA1tcuGS7g/QNtetJnxA6QEsCVTA==}
|
||||
cpu: [s390x]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-libvips-linux-s390x@1.2.0':
|
||||
resolution: {integrity: sha512-eMKfzDxLGT8mnmPJTNMcjfO33fLiTDsrMlUVcp6b96ETbnJmd4uvZxVJSKPQfS+odwfVaGifhsB07J1LynFehw==}
|
||||
cpu: [s390x]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-libvips-linux-x64@1.0.4':
|
||||
resolution: {integrity: sha512-MmWmQ3iPFZr0Iev+BAgVMb3ZyC4KeFc3jFxnNbEPas60e1cIfevbtuyf9nDGIzOaW9PdnDciJm+wFFaTlj5xYw==}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-libvips-linux-x64@1.2.0':
|
||||
resolution: {integrity: sha512-ZW3FPWIc7K1sH9E3nxIGB3y3dZkpJlMnkk7z5tu1nSkBoCgw2nSRTFHI5pB/3CQaJM0pdzMF3paf9ckKMSE9Tg==}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-libvips-linuxmusl-arm64@1.0.4':
|
||||
resolution: {integrity: sha512-9Ti+BbTYDcsbp4wfYib8Ctm1ilkugkA/uscUn6UXK1ldpC1JjiXbLfFZtRlBhjPZ5o1NCLiDbg8fhUPKStHoTA==}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@img/sharp-libvips-linuxmusl-arm64@1.2.0':
|
||||
resolution: {integrity: sha512-UG+LqQJbf5VJ8NWJ5Z3tdIe/HXjuIdo4JeVNADXBFuG7z9zjoegpzzGIyV5zQKi4zaJjnAd2+g2nna8TZvuW9Q==}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@img/sharp-libvips-linuxmusl-x64@1.0.4':
|
||||
resolution: {integrity: sha512-viYN1KX9m+/hGkJtvYYp+CCLgnJXwiQB39damAO7WMdKWlIhmYTfHjwSbQeUK/20vY154mwezd9HflVFM1wVSw==}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@img/sharp-libvips-linuxmusl-x64@1.2.0':
|
||||
resolution: {integrity: sha512-SRYOLR7CXPgNze8akZwjoGBoN1ThNZoqpOgfnOxmWsklTGVfJiGJoC/Lod7aNMGA1jSsKWM1+HRX43OP6p9+6Q==}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@img/sharp-linux-arm64@0.33.5':
|
||||
resolution: {integrity: sha512-JMVv+AMRyGOHtO1RFBiJy/MBsgz0x4AWrT6QoEVVTyh1E39TrCUpTRI7mx9VksGX4awWASxqCYLCV4wBZHAYxA==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-linux-arm64@0.34.3':
|
||||
resolution: {integrity: sha512-QdrKe3EvQrqwkDrtuTIjI0bu6YEJHTgEeqdzI3uWJOH6G1O8Nl1iEeVYRGdj1h5I21CqxSvQp1Yv7xeU3ZewbA==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-linux-arm@0.33.5':
|
||||
resolution: {integrity: sha512-JTS1eldqZbJxjvKaAkxhZmBqPRGmxgu+qFKSInv8moZ2AmT5Yib3EQ1c6gp493HvrvV8QgdOXdyaIBrhvFhBMQ==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [arm]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-linux-arm@0.34.3':
|
||||
resolution: {integrity: sha512-oBK9l+h6KBN0i3dC8rYntLiVfW8D8wH+NPNT3O/WBHeW0OQWCjfWksLUaPidsrDKpJgXp3G3/hkmhptAW0I3+A==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [arm]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-linux-ppc64@0.34.3':
|
||||
resolution: {integrity: sha512-GLtbLQMCNC5nxuImPR2+RgrviwKwVql28FWZIW1zWruy6zLgA5/x2ZXk3mxj58X/tszVF69KK0Is83V8YgWhLA==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [ppc64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-linux-s390x@0.33.5':
|
||||
resolution: {integrity: sha512-y/5PCd+mP4CA/sPDKl2961b+C9d+vPAveS33s6Z3zfASk2j5upL6fXVPZi7ztePZ5CuH+1kW8JtvxgbuXHRa4Q==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [s390x]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-linux-s390x@0.34.3':
|
||||
resolution: {integrity: sha512-3gahT+A6c4cdc2edhsLHmIOXMb17ltffJlxR0aC2VPZfwKoTGZec6u5GrFgdR7ciJSsHT27BD3TIuGcuRT0KmQ==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [s390x]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-linux-x64@0.33.5':
|
||||
resolution: {integrity: sha512-opC+Ok5pRNAzuvq1AG0ar+1owsu842/Ab+4qvU879ippJBHvyY5n2mxF1izXqkPYlGuP/M556uh53jRLJmzTWA==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-linux-x64@0.34.3':
|
||||
resolution: {integrity: sha512-8kYso8d806ypnSq3/Ly0QEw90V5ZoHh10yH0HnrzOCr6DKAPI6QVHvwleqMkVQ0m+fc7EH8ah0BB0QPuWY6zJQ==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@img/sharp-linuxmusl-arm64@0.33.5':
|
||||
resolution: {integrity: sha512-XrHMZwGQGvJg2V/oRSUfSAfjfPxO+4DkiRh6p2AFjLQztWUuY/o8Mq0eMQVIY7HJ1CDQUJlxGGZRw1a5bqmd1g==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@img/sharp-linuxmusl-arm64@0.34.3':
|
||||
resolution: {integrity: sha512-vAjbHDlr4izEiXM1OTggpCcPg9tn4YriK5vAjowJsHwdBIdx0fYRsURkxLG2RLm9gyBq66gwtWI8Gx0/ov+JKQ==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@img/sharp-linuxmusl-x64@0.33.5':
|
||||
resolution: {integrity: sha512-WT+d/cgqKkkKySYmqoZ8y3pxx7lx9vVejxW/W4DOFMYVSkErR+w7mf2u8m/y4+xHe7yY9DAXQMWQhpnMuFfScw==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@img/sharp-linuxmusl-x64@0.34.3':
|
||||
resolution: {integrity: sha512-gCWUn9547K5bwvOn9l5XGAEjVTTRji4aPTqLzGXHvIr6bIDZKNTA34seMPgM0WmSf+RYBH411VavCejp3PkOeQ==}
|
||||
engines: {node: ^18.17.0 || ^20.3.0 || >=21.0.0}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@img/sharp-wasm32@0.33.5':
|
||||
resolution: {integrity: sha512-ykUW4LVGaMcU9lu9thv85CbRMAwfeadCJHRsg2GmeRa/cJxsVY9Rbd57JcMxBkKHag5U/x7TSBpScF4U8ElVzg==}
|
||||
|
|
@ -2168,28 +2145,24 @@ packages:
|
|||
engines: {node: '>= 10'}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@next/swc-linux-arm64-musl@15.5.0':
|
||||
resolution: {integrity: sha512-biWqIOE17OW/6S34t1X8K/3vb1+svp5ji5QQT/IKR+VfM3B7GvlCwmz5XtlEan2ukOUf9tj2vJJBffaGH4fGRw==}
|
||||
engines: {node: '>= 10'}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@next/swc-linux-x64-gnu@15.5.0':
|
||||
resolution: {integrity: sha512-zPisT+obYypM/l6EZ0yRkK3LEuoZqHaSoYKj+5jiD9ESHwdr6QhnabnNxYkdy34uCigNlWIaCbjFmQ8FY5AlxA==}
|
||||
engines: {node: '>= 10'}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@next/swc-linux-x64-musl@15.5.0':
|
||||
resolution: {integrity: sha512-+t3+7GoU9IYmk+N+FHKBNFdahaReoAktdOpXHFIPOU1ixxtdge26NgQEEkJkCw2dHT9UwwK5zw4mAsURw4E8jA==}
|
||||
engines: {node: '>= 10'}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@next/swc-win32-arm64-msvc@15.5.0':
|
||||
resolution: {integrity: sha512-d8MrXKh0A+c9DLiy1BUFwtg3Hu90Lucj3k6iKTUdPOv42Ve2UiIG8HYi3UAb8kFVluXxEfdpCoPPCSODk5fDcw==}
|
||||
|
|
@ -2411,42 +2384,36 @@ packages:
|
|||
engines: {node: '>= 10.0.0'}
|
||||
cpu: [arm]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@parcel/watcher-linux-arm-musl@2.5.1':
|
||||
resolution: {integrity: sha512-6E+m/Mm1t1yhB8X412stiKFG3XykmgdIOqhjWj+VL8oHkKABfu/gjFj8DvLrYVHSBNC+/u5PeNrujiSQ1zwd1Q==}
|
||||
engines: {node: '>= 10.0.0'}
|
||||
cpu: [arm]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@parcel/watcher-linux-arm64-glibc@2.5.1':
|
||||
resolution: {integrity: sha512-LrGp+f02yU3BN9A+DGuY3v3bmnFUggAITBGriZHUREfNEzZh/GO06FF5u2kx8x+GBEUYfyTGamol4j3m9ANe8w==}
|
||||
engines: {node: '>= 10.0.0'}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@parcel/watcher-linux-arm64-musl@2.5.1':
|
||||
resolution: {integrity: sha512-cFOjABi92pMYRXS7AcQv9/M1YuKRw8SZniCDw0ssQb/noPkRzA+HBDkwmyOJYp5wXcsTrhxO0zq1U11cK9jsFg==}
|
||||
engines: {node: '>= 10.0.0'}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@parcel/watcher-linux-x64-glibc@2.5.1':
|
||||
resolution: {integrity: sha512-GcESn8NZySmfwlTsIur+49yDqSny2IhPeZfXunQi48DMugKeZ7uy1FX83pO0X22sHntJ4Ub+9k34XQCX+oHt2A==}
|
||||
engines: {node: '>= 10.0.0'}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@parcel/watcher-linux-x64-musl@2.5.1':
|
||||
resolution: {integrity: sha512-n0E2EQbatQ3bXhcH2D1XIAANAcTZkQICBPVaxMeaCVBtOpBZpWJuf7LwyWPSBDITb7In8mqQgJ7gH8CILCURXg==}
|
||||
engines: {node: '>= 10.0.0'}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@parcel/watcher-win32-arm64@2.5.1':
|
||||
resolution: {integrity: sha512-RFzklRvmc3PkjKjry3hLF9wD7ppR4AKcWNzH7kXR7GUe0Igb3Nz8fyPwtZCSquGrhU5HhUNDr/mKBqj7tqA2Vw==}
|
||||
|
|
@ -3561,49 +3528,41 @@ packages:
|
|||
resolution: {integrity: sha512-34gw7PjDGB9JgePJEmhEqBhWvCiiWCuXsL9hYphDF7crW7UgI05gyBAi6MF58uGcMOiOqSJ2ybEeCvHcq0BCmQ==}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@unrs/resolver-binding-linux-arm64-musl@1.11.1':
|
||||
resolution: {integrity: sha512-RyMIx6Uf53hhOtJDIamSbTskA99sPHS96wxVE/bJtePJJtpdKGXO1wY90oRdXuYOGOTuqjT8ACccMc4K6QmT3w==}
|
||||
cpu: [arm64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@unrs/resolver-binding-linux-ppc64-gnu@1.11.1':
|
||||
resolution: {integrity: sha512-D8Vae74A4/a+mZH0FbOkFJL9DSK2R6TFPC9M+jCWYia/q2einCubX10pecpDiTmkJVUH+y8K3BZClycD8nCShA==}
|
||||
cpu: [ppc64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@unrs/resolver-binding-linux-riscv64-gnu@1.11.1':
|
||||
resolution: {integrity: sha512-frxL4OrzOWVVsOc96+V3aqTIQl1O2TjgExV4EKgRY09AJ9leZpEg8Ak9phadbuX0BA4k8U5qtvMSQQGGmaJqcQ==}
|
||||
cpu: [riscv64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@unrs/resolver-binding-linux-riscv64-musl@1.11.1':
|
||||
resolution: {integrity: sha512-mJ5vuDaIZ+l/acv01sHoXfpnyrNKOk/3aDoEdLO/Xtn9HuZlDD6jKxHlkN8ZhWyLJsRBxfv9GYM2utQ1SChKew==}
|
||||
cpu: [riscv64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@unrs/resolver-binding-linux-s390x-gnu@1.11.1':
|
||||
resolution: {integrity: sha512-kELo8ebBVtb9sA7rMe1Cph4QHreByhaZ2QEADd9NzIQsYNQpt9UkM9iqr2lhGr5afh885d/cB5QeTXSbZHTYPg==}
|
||||
cpu: [s390x]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@unrs/resolver-binding-linux-x64-gnu@1.11.1':
|
||||
resolution: {integrity: sha512-C3ZAHugKgovV5YvAMsxhq0gtXuwESUKc5MhEtjBpLoHPLYM+iuwSj3lflFwK3DPm68660rZ7G8BMcwSro7hD5w==}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [glibc]
|
||||
|
||||
'@unrs/resolver-binding-linux-x64-musl@1.11.1':
|
||||
resolution: {integrity: sha512-rV0YSoyhK2nZ4vEswT/QwqzqQXw5I6CjoaYMOX0TqBlWhojUf8P94mvI7nuJTeaCkkds3QE4+zS8Ko+GdXuZtA==}
|
||||
cpu: [x64]
|
||||
os: [linux]
|
||||
libc: [musl]
|
||||
|
||||
'@unrs/resolver-binding-wasm32-wasi@1.11.1':
|
||||
resolution: {integrity: sha512-5u4RkfxJm+Ng7IWgkzi3qrFOvLvQYnPBmjmZQ8+szTK/b31fQCnleNl1GgEt7nIsZRIf5PLhPwT0WM+q45x/UQ==}
|
||||
|
|
@ -4407,6 +4366,10 @@ packages:
|
|||
create-require@1.1.1:
|
||||
resolution: {integrity: sha512-dcKFX3jn0MpIaXjisoRvexIJVEKzaq7z2rZKxf+MSr9TkdmHmsU4m2lcLojrj/FHl8mk5VxMmYA+ftRkP/3oKQ==}
|
||||
|
||||
cron-parser@5.4.0:
|
||||
resolution: {integrity: sha512-HxYB8vTvnQFx4dLsZpGRa0uHp6X3qIzS3ZJgJ9v6l/5TJMgeWQbLkR5yiJ5hOxGbc9+jCADDnydIe15ReLZnJA==}
|
||||
engines: {node: '>=18'}
|
||||
|
||||
cross-env@7.0.3:
|
||||
resolution: {integrity: sha512-+/HKd6EgcQCJGh2PSjZuUitQBQynKor4wrFbRg4DtAgS1aWO+gU52xpH7M9ScGgXSYmAVS9bIJ8EzuaGw0oNAw==}
|
||||
engines: {node: '>=10.14', npm: '>=6', yarn: '>=1'}
|
||||
|
|
@ -6275,6 +6238,10 @@ packages:
|
|||
lru-cache@5.1.1:
|
||||
resolution: {integrity: sha512-KpNARQA3Iwv+jTA0utUVVbrh+Jlrr1Fv0e56GGzAFOXN7dk/FviaDW8LHmK52DlcH4WP2n6gI8vN1aesBFgo9w==}
|
||||
|
||||
luxon@3.7.2:
|
||||
resolution: {integrity: sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==}
|
||||
engines: {node: '>=12'}
|
||||
|
||||
lz-string@1.5.0:
|
||||
resolution: {integrity: sha512-h5bgJWpxJNswbU7qCrV0tIKQCaS3blPDrqKWx+QxzuzL1zGUzij9XCWLrSLsJPu5t+eWA/ycetzYAO5IOMcWAQ==}
|
||||
hasBin: true
|
||||
|
|
@ -12980,6 +12947,10 @@ snapshots:
|
|||
|
||||
create-require@1.1.1: {}
|
||||
|
||||
cron-parser@5.4.0:
|
||||
dependencies:
|
||||
luxon: 3.7.2
|
||||
|
||||
cross-env@7.0.3:
|
||||
dependencies:
|
||||
cross-spawn: 7.0.6
|
||||
|
|
@ -15361,6 +15332,8 @@ snapshots:
|
|||
dependencies:
|
||||
yallist: 3.1.1
|
||||
|
||||
luxon@3.7.2: {}
|
||||
|
||||
lz-string@1.5.0: {}
|
||||
|
||||
magic-string@0.30.17:
|
||||
|
|
|
|||
Loading…
Reference in New Issue