fixed scheduletests

Author: YunchuWang

test/ScheduledTasks.Tests/Entity/ScheduleTests.cs

@@ -10,9 +10,9 @@ namespace Microsoft.DurableTask.ScheduledTasks.Tests.Entity;
 
 public class ScheduleTests
 {
-    private readonly Schedule schedule;
-    private readonly string scheduleId = "test-schedule";
-    private readonly TestLogger logger;
+    readonly Schedule schedule;
+    readonly string scheduleId = "test-schedule";
+    readonly TestLogger logger;
 
     public ScheduleTests(ITestOutputHelper output)
     {
@@ -21,9 +21,9 @@ public ScheduleTests(ITestOutputHelper output)
     }
 
     // Simple TestLogger implementation for capturing logs
-    private class TestLogger : ILogger<Schedule>
+    class TestLogger : ILogger<Schedule>
     {
-        public List<(LogLevel Level, string Message)> Logs { get; } = new List<(LogLevel, string)>();
+        public List<(LogLevel Level, string Message)> Logs { get; } = new();
 
         public IDisposable? BeginScope<TState>(TState state) where TState : notnull => null;
 
@@ -55,7 +55,7 @@ public async Task CreateSchedule_WithValidOptions_CreatesSchedule()
         await this.schedule.RunAsync(operation);
 
         // Assert
-        object? state = operation.State.GetState(typeof(ScheduleState));
+        var state = operation.State.GetState(typeof(ScheduleState));
         Assert.NotNull(state);
         ScheduleState scheduleState = Assert.IsType<ScheduleState>(state);
         Assert.NotNull(scheduleState.ScheduleConfiguration);
@@ -81,18 +81,36 @@ public async Task PauseSchedule_WhenAlreadyPaused_ThrowsInvalidTransitionExcepti
             createOptions);
         await this.schedule.RunAsync(createOperation);
 
+        // assert after create
+        var state = createOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(state);
+        ScheduleState scheduleState = Assert.IsType<ScheduleState>(state);
+        Assert.Equal(ScheduleStatus.Active, scheduleState.Status);
+
         // Pause first time
         TestEntityOperation pauseOperation = new TestEntityOperation(
             nameof(Schedule.PauseSchedule),
             createOperation.State,
             null);
         await this.schedule.RunAsync(pauseOperation);
 
+        // assert after first pause
+        var stateAfterFirstPause = pauseOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterFirstPause);
+        ScheduleState scheduleStateAfterFirstPause = Assert.IsType<ScheduleState>(stateAfterFirstPause);
+        Assert.Equal(ScheduleStatus.Paused, scheduleStateAfterFirstPause.Status);
+
+        // Pause second time
+        TestEntityOperation pauseOperation2 = new TestEntityOperation(
+            nameof(Schedule.PauseSchedule),
+            pauseOperation.State,
+            null);
+
         // Act & Assert
         await Assert.ThrowsAsync<ScheduleInvalidTransitionException>(() =>
             this.schedule.RunAsync(new TestEntityOperation(
                 nameof(Schedule.PauseSchedule),
-                pauseOperation.State,
+                pauseOperation2.State,
                 null)).AsTask());
     }
 
@@ -112,21 +130,37 @@ public async Task ResumeSchedule_WhenPaused_ResumesSchedule()
             createOptions);
         await this.schedule.RunAsync(createOperation);
 
+        // Assert initial state is active
+        var stateAfterCreate = createOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterCreate);
+        ScheduleState scheduleStateAfterCreate = Assert.IsType<ScheduleState>(stateAfterCreate);
+        Assert.Equal(ScheduleStatus.Active, scheduleStateAfterCreate.Status);
+
         // Pause
         TestEntityOperation pauseOperation = new TestEntityOperation(
             nameof(Schedule.PauseSchedule),
             createOperation.State,
             null);
         await this.schedule.RunAsync(pauseOperation);
 
+        // Assert paused state
+        var stateAfterPause = pauseOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterPause);
+        ScheduleState scheduleStateAfterPause = Assert.IsType<ScheduleState>(stateAfterPause);
+        Assert.Equal(ScheduleStatus.Paused, scheduleStateAfterPause.Status);
+
         // Act
         TestEntityOperation resumeOperation = new TestEntityOperation(
             nameof(Schedule.ResumeSchedule),
             pauseOperation.State,
             null);
         await this.schedule.RunAsync(resumeOperation);
 
-        // Assert
+        // Assert resumed state
+        var stateAfterResume = resumeOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterResume);
+        ScheduleState scheduleStateAfterResume = Assert.IsType<ScheduleState>(stateAfterResume);
+        Assert.Equal(ScheduleStatus.Active, scheduleStateAfterResume.Status);
     }
 
     [Fact]
@@ -145,6 +179,12 @@ public async Task ResumeSchedule_WhenActive_ThrowsInvalidTransitionException()
             createOptions);
         await this.schedule.RunAsync(createOperation);
 
+        // Assert initial state is active
+        object? stateAfterCreate = createOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterCreate);
+        ScheduleState scheduleStateAfterCreate = Assert.IsType<ScheduleState>(stateAfterCreate);
+        Assert.Equal(ScheduleStatus.Active, scheduleStateAfterCreate.Status);
+
         // Act & Assert
         await Assert.ThrowsAsync<ScheduleInvalidTransitionException>(() =>
             this.schedule.RunAsync(new TestEntityOperation(
@@ -169,6 +209,12 @@ public async Task UpdateSchedule_WithValidOptions_UpdatesSchedule()
             createOptions);
         await this.schedule.RunAsync(createOperation);
 
+        // Assert initial state
+        object? stateAfterCreate = createOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterCreate);
+        ScheduleState scheduleStateAfterCreate = Assert.IsType<ScheduleState>(stateAfterCreate);
+        Assert.Equal(TimeSpan.FromMinutes(5), scheduleStateAfterCreate.ScheduleConfiguration?.Interval);
+
         ScheduleUpdateOptions updateOptions = new ScheduleUpdateOptions
         {
             Interval = TimeSpan.FromMinutes(10)
@@ -181,7 +227,11 @@ public async Task UpdateSchedule_WithValidOptions_UpdatesSchedule()
             updateOptions);
         await this.schedule.RunAsync(updateOperation);
 
-        // Assert
+        // Assert updated state
+        object? stateAfterUpdate = updateOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterUpdate);
+        ScheduleState scheduleStateAfterUpdate = Assert.IsType<ScheduleState>(stateAfterUpdate);
+        Assert.Equal(TimeSpan.FromMinutes(10), scheduleStateAfterUpdate.ScheduleConfiguration?.Interval);
     }
 
     [Fact]
@@ -200,11 +250,17 @@ public async Task UpdateSchedule_WithNullOptions_ThrowsArgumentNullException()
             createOptions);
         await this.schedule.RunAsync(createOperation);
 
+        // Assert initial state
+        object? stateAfterCreate = createOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterCreate);
+        ScheduleState scheduleStateAfterCreate = Assert.IsType<ScheduleState>(stateAfterCreate);
+        Assert.Equal(TimeSpan.FromMinutes(5), scheduleStateAfterCreate.ScheduleConfiguration?.Interval);
+
         // Act & Assert
-        await Assert.ThrowsAsync<ScheduleClientValidationException>(() =>
+        await Assert.ThrowsAsync<InvalidOperationException>(() =>
             this.schedule.RunAsync(new TestEntityOperation(
                 nameof(Schedule.UpdateSchedule),
-                createOperation.State,
+                stateAfterCreate,
                 null)).AsTask());
     }
 
@@ -224,19 +280,33 @@ public async Task RunSchedule_WhenNotActive_ThrowsInvalidOperationException()
             createOptions);
         await this.schedule.RunAsync(createOperation);
 
+        // Assert initial state is active
+        object? stateAfterCreate = createOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterCreate);
+        ScheduleState scheduleStateAfterCreate = Assert.IsType<ScheduleState>(stateAfterCreate);
+        Assert.Equal(ScheduleStatus.Active, scheduleStateAfterCreate.Status);
+
         // Pause
         TestEntityOperation pauseOperation = new TestEntityOperation(
             nameof(Schedule.PauseSchedule),
             createOperation.State,
             null);
         await this.schedule.RunAsync(pauseOperation);
 
+        // Assert paused state
+        object? stateAfterPause = pauseOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterPause);
+        ScheduleState scheduleStateAfterPause = Assert.IsType<ScheduleState>(stateAfterPause);
+        Assert.Equal(ScheduleStatus.Paused, scheduleStateAfterPause.Status);
+
+        // run schedule op
+        TestEntityOperation runOp = new TestEntityOperation(
+                nameof(Schedule.RunSchedule),
+                scheduleStateAfterPause,
+                scheduleStateAfterPause.ExecutionToken);
         // Act & Assert
         await Assert.ThrowsAsync<InvalidOperationException>(() =>
-            this.schedule.RunAsync(new TestEntityOperation(
-                nameof(Schedule.RunSchedule),
-                pauseOperation.State,
-                "token")).AsTask());
+            this.schedule.RunAsync(runOp).AsTask());
     }
 
     [Fact]
@@ -255,12 +325,26 @@ public async Task RunSchedule_WithInvalidToken_DoesNotRun()
             createOptions);
         await this.schedule.RunAsync(createOperation);
 
+        // Assert initial state
+        object? stateAfterCreate = createOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterCreate);
+        ScheduleState scheduleStateAfterCreate = Assert.IsType<ScheduleState>(stateAfterCreate);
+        Assert.Equal(ScheduleStatus.Active, scheduleStateAfterCreate.Status);
+        string? initialToken = scheduleStateAfterCreate.ExecutionToken;
+
         // Act
-        await this.schedule.RunAsync(new TestEntityOperation(
+        TestEntityOperation runOperation = new TestEntityOperation(
             nameof(Schedule.RunSchedule),
             createOperation.State,
-            "invalid-token"));
-
-        // Assert
+            "invalid-token");
+        await this.schedule.RunAsync(runOperation);
+
+        // Assert state unchanged
+        object? stateAfterRun = runOperation.State.GetState(typeof(ScheduleState));
+        Assert.NotNull(stateAfterRun);
+        ScheduleState scheduleStateAfterRun = Assert.IsType<ScheduleState>(stateAfterRun);
+        Assert.Equal(ScheduleStatus.Active, scheduleStateAfterRun.Status);
+        Assert.Equal(initialToken, scheduleStateAfterRun.ExecutionToken);
+        Assert.Null(scheduleStateAfterRun.LastRunAt);
     }
 }