pyworkflow-engine 0.1.7__py3-none-any.whl → 0.1.10__py3-none-any.whl

tests/unit/test_schedule_schemas.py

@@ -1,285 +0,0 @@
-"""
-Unit tests for schedule schemas and data models.
-"""
-
-from datetime import UTC, datetime
-
-from pyworkflow.storage.schemas import (
-    CalendarSpec,
-    OverlapPolicy,
-    Schedule,
-    ScheduleSpec,
-    ScheduleStatus,
-)
-
-
-class TestOverlapPolicy:
-    """Test OverlapPolicy enum."""
-
-    def test_overlap_policy_values(self):
-        """Test all overlap policy values exist."""
-        assert OverlapPolicy.SKIP.value == "skip"
-        assert OverlapPolicy.BUFFER_ONE.value == "buffer_one"
-        assert OverlapPolicy.BUFFER_ALL.value == "buffer_all"
-        assert OverlapPolicy.CANCEL_OTHER.value == "cancel_other"
-        assert OverlapPolicy.ALLOW_ALL.value == "allow_all"
-
-    def test_overlap_policy_from_string(self):
-        """Test creating OverlapPolicy from string value."""
-        assert OverlapPolicy("skip") == OverlapPolicy.SKIP
-        assert OverlapPolicy("buffer_one") == OverlapPolicy.BUFFER_ONE
-
-
-class TestScheduleStatus:
-    """Test ScheduleStatus enum."""
-
-    def test_schedule_status_values(self):
-        """Test all schedule status values exist."""
-        assert ScheduleStatus.ACTIVE.value == "active"
-        assert ScheduleStatus.PAUSED.value == "paused"
-        assert ScheduleStatus.DELETED.value == "deleted"
-
-    def test_schedule_status_from_string(self):
-        """Test creating ScheduleStatus from string value."""
-        assert ScheduleStatus("active") == ScheduleStatus.ACTIVE
-        assert ScheduleStatus("paused") == ScheduleStatus.PAUSED
-
-
-class TestCalendarSpec:
-    """Test CalendarSpec dataclass."""
-
-    def test_calendar_spec_defaults(self):
-        """Test CalendarSpec default values."""
-        spec = CalendarSpec()
-        assert spec.second == 0
-        assert spec.minute == 0
-        assert spec.hour == 0
-        assert spec.day_of_month is None
-        assert spec.month is None
-        assert spec.day_of_week is None
-
-    def test_calendar_spec_with_values(self):
-        """Test CalendarSpec with specific values."""
-        spec = CalendarSpec(
-            second=30,
-            minute=15,
-            hour=9,
-            day_of_month=1,
-            month=6,
-            day_of_week=1,
-        )
-        assert spec.second == 30
-        assert spec.minute == 15
-        assert spec.hour == 9
-        assert spec.day_of_month == 1
-        assert spec.month == 6
-        assert spec.day_of_week == 1
-
-
-class TestScheduleSpec:
-    """Test ScheduleSpec dataclass."""
-
-    def test_schedule_spec_defaults(self):
-        """Test ScheduleSpec default values."""
-        spec = ScheduleSpec()
-        assert spec.cron is None
-        assert spec.interval is None
-        assert spec.calendar is None
-        assert spec.timezone == "UTC"
-        assert spec.start_at is None
-        assert spec.end_at is None
-        assert spec.jitter is None
-
-    def test_schedule_spec_with_cron(self):
-        """Test ScheduleSpec with cron expression."""
-        spec = ScheduleSpec(cron="0 9 * * *")
-        assert spec.cron == "0 9 * * *"
-        assert spec.interval is None
-
-    def test_schedule_spec_with_interval(self):
-        """Test ScheduleSpec with interval."""
-        spec = ScheduleSpec(interval="5m")
-        assert spec.interval == "5m"
-        assert spec.cron is None
-
-    def test_schedule_spec_with_calendar(self):
-        """Test ScheduleSpec with calendar entries."""
-        calendars = [
-            CalendarSpec(day_of_month=1, hour=0, minute=0),
-            CalendarSpec(day_of_month=15, hour=12, minute=0),
-        ]
-        spec = ScheduleSpec(calendar=calendars)
-        assert len(spec.calendar) == 2
-        assert spec.calendar[0].day_of_month == 1
-
-    def test_schedule_spec_with_timezone(self):
-        """Test ScheduleSpec with custom timezone."""
-        spec = ScheduleSpec(cron="0 9 * * *", timezone="America/New_York")
-        assert spec.timezone == "America/New_York"
-
-    def test_schedule_spec_with_time_bounds(self):
-        """Test ScheduleSpec with start_at and end_at."""
-        start = datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
-        end = datetime(2024, 12, 31, 23, 59, 59, tzinfo=UTC)
-
-        spec = ScheduleSpec(
-            cron="0 9 * * *",
-            start_at=start,
-            end_at=end,
-        )
-        assert spec.start_at == start
-        assert spec.end_at == end
-
-
-class TestSchedule:
-    """Test Schedule dataclass."""
-
-    def test_schedule_defaults(self):
-        """Test Schedule default values."""
-        spec = ScheduleSpec(cron="0 9 * * *")
-        schedule = Schedule(
-            schedule_id="test_sched",
-            workflow_name="test_workflow",
-            spec=spec,
-        )
-
-        assert schedule.schedule_id == "test_sched"
-        assert schedule.workflow_name == "test_workflow"
-        assert schedule.status == ScheduleStatus.ACTIVE
-        assert schedule.args == "[]"
-        assert schedule.kwargs == "{}"
-        assert schedule.overlap_policy == OverlapPolicy.SKIP
-        assert schedule.total_runs == 0
-        assert schedule.successful_runs == 0
-        assert schedule.failed_runs == 0
-        assert schedule.skipped_runs == 0
-        assert schedule.buffered_count == 0
-        assert schedule.running_run_ids == []
-
-    def test_schedule_with_all_values(self):
-        """Test Schedule with all values specified."""
-        spec = ScheduleSpec(cron="0 9 * * *")
-        now = datetime.now(UTC)
-
-        schedule = Schedule(
-            schedule_id="sched_123",
-            workflow_name="my_workflow",
-            spec=spec,
-            status=ScheduleStatus.PAUSED,
-            args='["arg1", "arg2"]',
-            kwargs='{"key": "value"}',
-            overlap_policy=OverlapPolicy.BUFFER_ONE,
-            created_at=now,
-            updated_at=now,
-            next_run_time=now,
-            last_run_at=now,
-            total_runs=10,
-            successful_runs=8,
-            failed_runs=2,
-            skipped_runs=1,
-            buffered_count=0,
-            running_run_ids=["run_1", "run_2"],
-        )
-
-        assert schedule.schedule_id == "sched_123"
-        assert schedule.status == ScheduleStatus.PAUSED
-        assert schedule.overlap_policy == OverlapPolicy.BUFFER_ONE
-        assert schedule.total_runs == 10
-        assert schedule.successful_runs == 8
-        assert schedule.failed_runs == 2
-        assert len(schedule.running_run_ids) == 2
-
-    def test_schedule_to_dict(self):
-        """Test Schedule to_dict method."""
-        spec = ScheduleSpec(cron="0 9 * * *", timezone="UTC")
-        now = datetime.now(UTC)
-
-        schedule = Schedule(
-            schedule_id="sched_test",
-            workflow_name="test_workflow",
-            spec=spec,
-            created_at=now,
-        )
-
-        data = schedule.to_dict()
-
-        assert data["schedule_id"] == "sched_test"
-        assert data["workflow_name"] == "test_workflow"
-        assert data["status"] == "active"
-        assert data["overlap_policy"] == "skip"
-        assert "spec" in data
-        assert data["spec"]["cron"] == "0 9 * * *"
-
-    def test_schedule_from_dict(self):
-        """Test Schedule from_dict method."""
-        now = datetime.now(UTC)
-        data = {
-            "schedule_id": "sched_from_dict",
-            "workflow_name": "dict_workflow",
-            "spec": {
-                "cron": "*/5 * * * *",
-                "interval": None,
-                "calendar": None,
-                "timezone": "UTC",
-                "start_at": None,
-                "end_at": None,
-                "jitter": None,
-            },
-            "status": "active",
-            "args": "[]",
-            "kwargs": "{}",
-            "overlap_policy": "buffer_one",
-            "created_at": now.isoformat(),
-            "updated_at": None,
-            "next_run_time": None,
-            "last_run_at": None,
-            "total_runs": 5,
-            "successful_runs": 4,
-            "failed_runs": 1,
-            "skipped_runs": 0,
-            "buffered_count": 0,
-            "running_run_ids": [],
-        }
-
-        schedule = Schedule.from_dict(data)
-
-        assert schedule.schedule_id == "sched_from_dict"
-        assert schedule.workflow_name == "dict_workflow"
-        assert schedule.spec.cron == "*/5 * * * *"
-        assert schedule.status == ScheduleStatus.ACTIVE
-        assert schedule.overlap_policy == OverlapPolicy.BUFFER_ONE
-        assert schedule.total_runs == 5
-
-    def test_schedule_roundtrip(self):
-        """Test Schedule to_dict/from_dict roundtrip."""
-        spec = ScheduleSpec(
-            cron="0 */4 * * *",
-            timezone="Europe/London",
-        )
-        now = datetime.now(UTC)
-
-        original = Schedule(
-            schedule_id="roundtrip_test",
-            workflow_name="roundtrip_workflow",
-            spec=spec,
-            status=ScheduleStatus.ACTIVE,
-            overlap_policy=OverlapPolicy.CANCEL_OTHER,
-            created_at=now,
-            total_runs=100,
-            successful_runs=95,
-            failed_runs=5,
-        )
-
-        # Convert to dict and back
-        data = original.to_dict()
-        restored = Schedule.from_dict(data)
-
-        assert restored.schedule_id == original.schedule_id
-        assert restored.workflow_name == original.workflow_name
-        assert restored.spec.cron == original.spec.cron
-        assert restored.spec.timezone == original.spec.timezone
-        assert restored.status == original.status
-        assert restored.overlap_policy == original.overlap_policy
-        assert restored.total_runs == original.total_runs
-        assert restored.successful_runs == original.successful_runs
-        assert restored.failed_runs == original.failed_runs

tests/unit/test_schedule_utils.py

@@ -1,286 +0,0 @@
-"""
-Unit tests for schedule utility functions.
-"""
-
-from datetime import UTC, datetime, timedelta
-
-from pyworkflow.storage.schemas import CalendarSpec, ScheduleSpec
-from pyworkflow.utils.schedule import (
-    calculate_backfill_times,
-    calculate_next_run_time,
-    describe_schedule,
-    validate_cron_expression,
-)
-
-
-class TestValidateCronExpression:
-    """Test cron expression validation."""
-
-    def test_valid_cron_expressions(self):
-        """Test valid cron expressions."""
-        valid_expressions = [
-            "* * * * *",  # Every minute
-            "0 * * * *",  # Every hour
-            "0 0 * * *",  # Every day at midnight
-            "0 9 * * *",  # Every day at 9 AM
-            "0 9 * * 1",  # Every Monday at 9 AM
-            "0 0 1 * *",  # First day of every month
-            "*/5 * * * *",  # Every 5 minutes
-            "0 */4 * * *",  # Every 4 hours
-            "0 9-17 * * 1-5",  # 9 AM to 5 PM, Monday to Friday
-            "0 0 1,15 * *",  # 1st and 15th of every month
-        ]
-
-        for expr in valid_expressions:
-            assert validate_cron_expression(expr), f"Expected '{expr}' to be valid"
-
-    def test_invalid_cron_expressions(self):
-        """Test invalid cron expressions."""
-        invalid_expressions = [
-            "",  # Empty
-            "* * *",  # Too few fields
-            "60 * * * *",  # Invalid minute
-            "* 25 * * *",  # Invalid hour
-            "* * 32 * *",  # Invalid day of month
-            "* * * 13 *",  # Invalid month
-            "* * * * 8",  # Invalid day of week
-            "invalid",  # Not a cron expression
-        ]
-
-        for expr in invalid_expressions:
-            assert not validate_cron_expression(expr), f"Expected '{expr}' to be invalid"
-
-
-class TestCalculateNextRunTime:
-    """Test next run time calculation."""
-
-    def test_next_run_time_cron(self):
-        """Test next run time calculation for cron expression."""
-        spec = ScheduleSpec(cron="0 9 * * *")  # Daily at 9 AM
-        now = datetime(2024, 1, 15, 8, 0, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, now=now)
-
-        assert next_time is not None
-        # Should be at 9 AM (today or tomorrow)
-        assert next_time.hour == 9
-        assert next_time.minute == 0
-
-    def test_next_run_time_interval(self):
-        """Test next run time calculation for interval."""
-        spec = ScheduleSpec(interval="5m")
-        now = datetime(2024, 1, 15, 8, 0, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, now=now)
-
-        assert next_time is not None
-        # First run with no last_run returns base_time (runs immediately)
-        assert next_time == now
-
-    def test_next_run_time_interval_with_last_run(self):
-        """Test next run time calculation for interval with last run."""
-        spec = ScheduleSpec(interval="10m")
-        now = datetime(2024, 1, 15, 8, 0, 0, tzinfo=UTC)
-        last_run = datetime(2024, 1, 15, 7, 55, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, last_run=last_run, now=now)
-
-        assert next_time is not None
-        # Should be 10 minutes after last run
-        expected = last_run + timedelta(minutes=10)
-        assert next_time == expected
-
-    def test_next_run_time_calendar(self):
-        """Test next run time calculation for calendar spec."""
-        spec = ScheduleSpec(calendar=[CalendarSpec(day_of_month=1, hour=0, minute=0)])
-        now = datetime(2024, 1, 15, 8, 0, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, now=now)
-
-        assert next_time is not None
-        # Should be first of next month
-        assert next_time.day == 1
-        assert next_time.hour == 0
-        assert next_time.minute == 0
-
-    def test_next_run_time_empty_spec(self):
-        """Test next run time with empty spec returns None."""
-        spec = ScheduleSpec()  # No cron, interval, or calendar
-
-        next_time = calculate_next_run_time(spec)
-
-        assert next_time is None
-
-    def test_next_run_time_respects_start_at(self):
-        """Test next run time respects start_at constraint."""
-        start_at = datetime(2024, 6, 1, 0, 0, 0, tzinfo=UTC)
-        spec = ScheduleSpec(
-            interval="1h",
-            start_at=start_at,
-        )
-        now = datetime(2024, 1, 15, 8, 0, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, now=now)
-
-        assert next_time is not None
-        # Should not be before start_at
-        assert next_time >= start_at
-
-    def test_next_run_time_respects_end_at(self):
-        """Test next run time returns None after end_at."""
-        end_at = datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
-        spec = ScheduleSpec(
-            interval="1h",
-            end_at=end_at,
-        )
-        now = datetime(2024, 1, 15, 8, 0, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, now=now)
-
-        # Should be None since we're past end_at
-        assert next_time is None
-
-
-class TestCalculateBackfillTimes:
-    """Test backfill time calculation."""
-
-    def test_backfill_times_cron(self):
-        """Test backfill times for cron expression."""
-        spec = ScheduleSpec(cron="0 9 * * *")  # Daily at 9 AM
-        start = datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
-        end = datetime(2024, 1, 5, 0, 0, 0, tzinfo=UTC)
-
-        times = calculate_backfill_times(spec, start, end)
-
-        # Should have 4 times (Jan 1, 2, 3, 4 at 9 AM)
-        assert len(times) == 4
-        for t in times:
-            assert t.hour == 9
-            assert t.minute == 0
-
-    def test_backfill_times_interval(self):
-        """Test backfill times for interval."""
-        spec = ScheduleSpec(interval="1h")
-        start = datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
-        end = datetime(2024, 1, 1, 5, 0, 0, tzinfo=UTC)
-
-        times = calculate_backfill_times(spec, start, end)
-
-        # Backfill starts from start and goes up to (but not including) end
-        # hours 1, 2, 3, 4 (first interval happens at start+1h)
-        assert len(times) >= 4
-
-    def test_backfill_times_empty_range(self):
-        """Test backfill times with empty range."""
-        spec = ScheduleSpec(cron="0 9 * * *")
-        start = datetime(2024, 1, 1, 10, 0, 0, tzinfo=UTC)
-        end = datetime(2024, 1, 1, 11, 0, 0, tzinfo=UTC)
-
-        times = calculate_backfill_times(spec, start, end)
-
-        # No 9 AM in this range
-        assert len(times) == 0
-
-    def test_backfill_times_invalid_range(self):
-        """Test backfill times with start after end."""
-        spec = ScheduleSpec(interval="1h")
-        start = datetime(2024, 1, 2, 0, 0, 0, tzinfo=UTC)
-        end = datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
-
-        times = calculate_backfill_times(spec, start, end)
-
-        assert len(times) == 0
-
-
-class TestDescribeSchedule:
-    """Test schedule description generation."""
-
-    def test_describe_cron(self):
-        """Test description for cron expression."""
-        spec = ScheduleSpec(cron="0 9 * * *")
-
-        description = describe_schedule(spec)
-
-        assert "cron" in description.lower() or "0 9 * * *" in description
-
-    def test_describe_interval(self):
-        """Test description for interval."""
-        spec = ScheduleSpec(interval="5m")
-
-        description = describe_schedule(spec)
-
-        assert "5m" in description or "interval" in description.lower()
-
-    def test_describe_calendar(self):
-        """Test description for calendar spec."""
-        spec = ScheduleSpec(calendar=[CalendarSpec(day_of_month=1, hour=0, minute=0)])
-
-        description = describe_schedule(spec)
-
-        assert description  # Should have some description
-
-    def test_describe_empty_spec(self):
-        """Test description for empty spec."""
-        spec = ScheduleSpec()
-
-        description = describe_schedule(spec)
-
-        assert "no" in description.lower() or "unspecified" in description.lower()
-
-
-class TestIntervalParsing:
-    """Test interval duration parsing with last_run."""
-
-    def test_seconds_interval(self):
-        """Test seconds interval parsing."""
-        spec = ScheduleSpec(interval="30s")
-        now = datetime(2024, 1, 1, 0, 0, 30, tzinfo=UTC)
-        last_run = datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, last_run=last_run, now=now)
-
-        expected = last_run + timedelta(seconds=30)
-        assert next_time == expected
-
-    def test_minutes_interval(self):
-        """Test minutes interval parsing."""
-        spec = ScheduleSpec(interval="15m")
-        now = datetime(2024, 1, 1, 0, 15, 0, tzinfo=UTC)
-        last_run = datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, last_run=last_run, now=now)
-
-        expected = last_run + timedelta(minutes=15)
-        assert next_time == expected
-
-    def test_hours_interval(self):
-        """Test hours interval parsing."""
-        spec = ScheduleSpec(interval="2h")
-        now = datetime(2024, 1, 1, 2, 0, 0, tzinfo=UTC)
-        last_run = datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, last_run=last_run, now=now)
-
-        expected = last_run + timedelta(hours=2)
-        assert next_time == expected
-
-    def test_days_interval(self):
-        """Test days interval parsing."""
-        spec = ScheduleSpec(interval="1d")
-        now = datetime(2024, 1, 2, 0, 0, 0, tzinfo=UTC)
-        last_run = datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, last_run=last_run, now=now)
-
-        expected = last_run + timedelta(days=1)
-        assert next_time == expected
-
-    def test_first_interval_runs_immediately(self):
-        """Test that first interval run (no last_run) runs at base_time."""
-        spec = ScheduleSpec(interval="5m")
-        now = datetime(2024, 1, 1, 0, 0, 0, tzinfo=UTC)
-
-        next_time = calculate_next_run_time(spec, now=now)
-
-        # First run should be immediate (at now)
-        assert next_time == now