fix(testing-sdk): update WaitDetails to use scheduled_end_timestamp and use datetime

Author: vip-amzn

.github/workflows/deploy-examples.yml

@@ -96,6 +96,10 @@ jobs:
         echo "QUALIFIED_FUNCTION_NAME=$QUALIFIED_FUNCTION_NAME" >> $GITHUB_ENV
         echo "VERSION=$VERSION" >> $GITHUB_ENV
 
+        # Wait for function to be ready
+        echo "Waiting for function to be active..."
+        aws lambda wait function-active --function-name "$QUALIFIED_FUNCTION_NAME" --endpoint-url "$LAMBDA_ENDPOINT" --region "${{ env.AWS_REGION }}"
+
     - name: Invoke Lambda function - ${{ matrix.example.name }}
       env:
         LAMBDA_ENDPOINT: ${{ secrets.LAMBDA_ENDPOINT_BETA }}

examples/test/test_wait.py

@@ -21,4 +21,4 @@ def test_wait():
     wait_ops = [op for op in result.operations if op.operation_type.value == "WAIT"]
     assert len(wait_ops) == 1
     wait_op = wait_ops[0]
-    assert wait_op.scheduled_timestamp is not None
+    assert wait_op.scheduled_end_timestamp is not None

src/aws_durable_execution_sdk_python_testing/checkpoint/processors/base.py

@@ -122,12 +122,14 @@ def _create_wait_details(
         """Create WaitDetails from OperationUpdate."""
         if update.operation_type == OperationType.WAIT and update.wait_options:
             if current_operation and current_operation.wait_details:
-                scheduled_timestamp = current_operation.wait_details.scheduled_timestamp
+                scheduled_end_timestamp = (
+                    current_operation.wait_details.scheduled_end_timestamp
+                )
             else:
-                scheduled_timestamp = datetime.datetime.now(
+                scheduled_end_timestamp = datetime.datetime.now(
                     tz=datetime.UTC
                 ) + timedelta(seconds=update.wait_options.wait_seconds)
-            return WaitDetails(scheduled_timestamp=scheduled_timestamp)
+            return WaitDetails(scheduled_end_timestamp=scheduled_end_timestamp)
         return None
 
     def _translate_update_to_operation(

src/aws_durable_execution_sdk_python_testing/checkpoint/processors/wait.py

@@ -41,12 +41,14 @@ def process(
                 wait_seconds = (
                     update.wait_options.wait_seconds if update.wait_options else 0
                 )
-                scheduled_timestamp = datetime.now(UTC) + timedelta(
+                scheduled_end_timestamp = datetime.now(UTC) + timedelta(
                     seconds=wait_seconds
                 )
 
                 # Create WaitDetails with scheduled timestamp
-                wait_details = WaitDetails(scheduled_timestamp=scheduled_timestamp)
+                wait_details = WaitDetails(
+                    scheduled_end_timestamp=scheduled_end_timestamp
+                )
 
                 # Create new operation with wait details
                 wait_operation = Operation(

src/aws_durable_execution_sdk_python_testing/executor.py

@@ -142,17 +142,15 @@ def get_execution_details(self, execution_arn: str) -> GetDurableExecutionRespon
             durable_execution_name=execution.start_input.execution_name,
             function_arn=f"arn:aws:lambda:us-east-1:123456789012:function:{execution.start_input.function_name}",
             status=status,
-            start_timestamp=execution_op.start_timestamp.timestamp()
+            start_timestamp=execution_op.start_timestamp
             if execution_op.start_timestamp
-            else datetime.now(UTC).timestamp(),
+            else datetime.now(UTC),
             input_payload=execution_op.execution_details.input_payload
             if execution_op.execution_details
             else None,
             result=result,
             error=error,
-            end_timestamp=execution_op.end_timestamp.timestamp()
-            if execution_op.end_timestamp
-            else None,
+            end_timestamp=execution_op.end_timestamp,
             version="1.0",
         )
 
@@ -223,12 +221,10 @@ def list_executions(
                 durable_execution_name=execution.start_input.execution_name,
                 function_arn=f"arn:aws:lambda:us-east-1:123456789012:function:{execution.start_input.function_name}",
                 status=execution_status,
-                start_timestamp=execution_op.start_timestamp.timestamp()
+                start_timestamp=execution_op.start_timestamp
                 if execution_op.start_timestamp
-                else datetime.now(UTC).timestamp(),
-                end_timestamp=execution_op.end_timestamp.timestamp()
-                if execution_op.end_timestamp
-                else None,
+                else datetime.now(UTC),
+                end_timestamp=execution_op.end_timestamp,
             )
             filtered_executions.append(execution_summary)
 
@@ -333,7 +329,7 @@ def stop_execution(
         # Stop the execution
         self.fail_execution(execution_arn, stop_error)
 
-        return StopDurableExecutionResponse(end_timestamp=datetime.now(UTC).timestamp())
+        return StopDurableExecutionResponse(stop_timestamp=datetime.now(UTC))
 
     def get_execution_state(
         self,

src/aws_durable_execution_sdk_python_testing/model.py

@@ -3,7 +3,11 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any
+from typing import TYPE_CHECKING, Any
+
+
+if TYPE_CHECKING:
+    import datetime
 
 # Import existing types from the main SDK - REUSE EVERYTHING POSSIBLE
 from aws_durable_execution_sdk_python.lambda_service import (
@@ -156,11 +160,11 @@ class GetDurableExecutionResponse:
     durable_execution_name: str
     function_arn: str
     status: str
-    start_timestamp: float
+    start_timestamp: datetime.datetime
     input_payload: str | None = None
     result: str | None = None
     error: ErrorObject | None = None
-    end_timestamp: float | None = None
+    end_timestamp: datetime.datetime | None = None
     version: str | None = None
 
     @classmethod
@@ -213,8 +217,8 @@ class Execution:
     durable_execution_name: str
     function_arn: str
     status: str
-    start_timestamp: float
-    end_timestamp: float | None = None
+    start_timestamp: datetime.datetime
+    end_timestamp: datetime.datetime | None = None
 
     @classmethod
     def from_dict(cls, data: dict) -> Execution:
@@ -350,14 +354,14 @@ def to_dict(self) -> dict[str, Any]:
 class StopDurableExecutionResponse:
     """Response from stopping a durable execution."""
 
-    end_timestamp: float
+    stop_timestamp: datetime.datetime
 
     @classmethod
     def from_dict(cls, data: dict) -> StopDurableExecutionResponse:
-        return cls(end_timestamp=data["EndTimestamp"])
+        return cls(stop_timestamp=data["StopTimestamp"])
 
     def to_dict(self) -> dict[str, Any]:
-        return {"EndTimestamp": self.end_timestamp}
+        return {"StopTimestamp": self.stop_timestamp}
 
 
 @dataclass(frozen=True)
@@ -676,7 +680,7 @@ class WaitStartedDetails:
     """Wait started event details."""
 
     duration: int | None = None
-    scheduled_end_timestamp: str | None = None
+    scheduled_end_timestamp: datetime.datetime | None = None  # Already correct!
 
     @classmethod
     def from_dict(cls, data: dict) -> WaitStartedDetails:
@@ -1010,7 +1014,7 @@ class Event:
     """Event structure from Smithy model."""
 
     event_type: str
-    event_timestamp: str
+    event_timestamp: datetime.datetime
     sub_type: str | None = None
     event_id: int = 1
     operation_id: str | None = None
@@ -1328,8 +1332,8 @@ class ListDurableExecutionsByFunctionRequest:
     qualifier: str | None = None
     durable_execution_name: str | None = None
     status_filter: list[str] | None = None
-    time_after: str | None = None
-    time_before: str | None = None
+    started_after: str | None = None
+    started_before: str | None = None
     marker: str | None = None
     max_items: int = 0
     reverse_order: bool | None = None
@@ -1341,8 +1345,8 @@ def from_dict(cls, data: dict) -> ListDurableExecutionsByFunctionRequest:
             qualifier=data.get("Qualifier"),
             durable_execution_name=data.get("DurableExecutionName"),
             status_filter=data.get("StatusFilter"),
-            time_after=data.get("TimeAfter"),
-            time_before=data.get("TimeBefore"),
+            started_after=data.get("StartedAfter"),
+            started_before=data.get("StartedBefore"),
             marker=data.get("Marker"),
             max_items=data.get("MaxItems", 0),
             reverse_order=data.get("ReverseOrder"),
@@ -1356,10 +1360,10 @@ def to_dict(self) -> dict[str, Any]:
             result["DurableExecutionName"] = self.durable_execution_name
         if self.status_filter is not None:
             result["StatusFilter"] = self.status_filter
-        if self.time_after is not None:
-            result["TimeAfter"] = self.time_after
-        if self.time_before is not None:
-            result["TimeBefore"] = self.time_before
+        if self.started_after is not None:
+            result["StartedAfter"] = self.started_after
+        if self.started_before is not None:
+            result["StartedBefore"] = self.started_before
         if self.marker is not None:
             result["Marker"] = self.marker
         if self.max_items is not None:

src/aws_durable_execution_sdk_python_testing/runner.py

@@ -267,7 +267,7 @@ def from_svc_operation(
 
 @dataclass(frozen=True)
 class WaitOperation(Operation):
-    scheduled_timestamp: datetime.datetime | None = None
+    scheduled_end_timestamp: datetime.datetime | None = None
 
     @staticmethod
     def from_svc_operation(
@@ -286,8 +286,8 @@ def from_svc_operation(
             sub_type=operation.sub_type,
             start_timestamp=operation.start_timestamp,
             end_timestamp=operation.end_timestamp,
-            scheduled_timestamp=(
-                operation.wait_details.scheduled_timestamp
+            scheduled_end_timestamp=(
+                operation.wait_details.scheduled_end_timestamp
                 if operation.wait_details
                 else None
             ),

src/aws_durable_execution_sdk_python_testing/web/handlers.py

@@ -578,9 +578,9 @@ def handle(self, parsed_route: Route, request: HTTPRequest) -> HTTPResponse:
             if status_filter := self._parse_query_param(request, "statusFilter"):
                 query_params["StatusFilter"] = [status_filter]  # Convert to list
             if time_after := self._parse_query_param(request, "timeAfter"):
-                query_params["TimeAfter"] = time_after
+                query_params["StartedAfter"] = time_after
             if time_before := self._parse_query_param(request, "timeBefore"):
-                query_params["TimeBefore"] = time_before
+                query_params["StartedBefore"] = time_before
             if marker := self._parse_query_param(request, "marker"):
                 query_params["Marker"] = marker
             if max_items_str := self._parse_query_param(request, "maxItems"):
@@ -608,8 +608,8 @@ def handle(self, parsed_route: Route, request: HTTPRequest) -> HTTPResponse:
                     status_filter=list_request.status_filter[0]
                     if list_request.status_filter
                     else None,
-                    time_after=list_request.time_after,
-                    time_before=list_request.time_before,
+                    time_after=list_request.started_after,
+                    time_before=list_request.started_before,
                     marker=list_request.marker,
                     max_items=list_request.max_items
                     if list_request.max_items > 0

tests/checkpoint/processors/base_test.py

@@ -320,7 +320,7 @@ def test_create_wait_details_with_current_operation():
     processor = MockProcessor()
     scheduled_time = datetime.datetime.now(tz=datetime.UTC)
     current_op = Mock()
-    current_op.wait_details = WaitDetails(scheduled_timestamp=scheduled_time)
+    current_op.wait_details = WaitDetails(scheduled_end_timestamp=scheduled_time)
 
     wait_options = WaitOptions(wait_seconds=30)
     update = OperationUpdate(
@@ -333,7 +333,7 @@ def test_create_wait_details_with_current_operation():
     result = processor.create_wait_details(update, current_op)
 
     assert isinstance(result, WaitDetails)
-    assert result.scheduled_timestamp == scheduled_time
+    assert result.scheduled_end_timestamp == scheduled_time
 
 
 def test_create_wait_details_without_current_operation():
@@ -349,7 +349,7 @@ def test_create_wait_details_without_current_operation():
     result = processor.create_wait_details(update, None)
 
     assert isinstance(result, WaitDetails)
-    assert result.scheduled_timestamp > datetime.datetime.now(tz=datetime.UTC)
+    assert result.scheduled_end_timestamp > datetime.datetime.now(tz=datetime.UTC)
 
 
 def test_create_wait_details_non_wait_type():

tests/checkpoint/processors/wait_test.py

@@ -67,7 +67,7 @@ def test_process_start_action():
     assert result.status == OperationStatus.STARTED
     assert result.name == "test-wait"
     assert result.wait_details is not None
-    assert result.wait_details.scheduled_timestamp > datetime.now(UTC)
+    assert result.wait_details.scheduled_end_timestamp > datetime.now(UTC)
 
     assert len(notifier.wait_timer_calls) == 1
     assert notifier.wait_timer_calls[0] == (execution_arn, "wait-123", 30)
@@ -269,7 +269,7 @@ def test_wait_details_created_correctly():
     before_time = datetime.now(UTC)
     result = processor.process(update, None, notifier, execution_arn)
 
-    assert result.wait_details.scheduled_timestamp > before_time
+    assert result.wait_details.scheduled_end_timestamp > before_time
 
 
 def test_no_completed_or_failed_calls():