fix: update StartDate to StartTimestamp and StopDate to EndTimestamp

Author: bchampp

src/aws_durable_execution_sdk_python_testing/executor.py

@@ -142,15 +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_date=execution_op.start_timestamp.isoformat()
+            start_timestamp=execution_op.start_timestamp.isoformat()
             if execution_op.start_timestamp
             else datetime.now(UTC).isoformat(),
             input_payload=execution_op.execution_details.input_payload
             if execution_op.execution_details
             else None,
             result=result,
             error=error,
-            stop_date=execution_op.end_timestamp.isoformat()
+            end_timestamp=execution_op.end_timestamp.isoformat()
             if execution_op.end_timestamp
             else None,
             version="1.0",
@@ -223,17 +223,17 @@ 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_date=execution_op.start_timestamp.isoformat()
+                start_timestamp=execution_op.start_timestamp.isoformat()
                 if execution_op.start_timestamp
                 else datetime.now(UTC).isoformat(),
-                stop_date=execution_op.end_timestamp.isoformat()
+                end_timestamp=execution_op.end_timestamp.isoformat()
                 if execution_op.end_timestamp
                 else None,
             )
             filtered_executions.append(execution_summary)
 
         # Sort by start date
-        filtered_executions.sort(key=lambda e: e.start_date, reverse=reverse_order)
+        filtered_executions.sort(key=lambda e: e.start_timestamp, reverse=reverse_order)
 
         # Apply pagination
         if max_items is None:
@@ -333,7 +333,7 @@ def stop_execution(
         # Stop the execution
         self.fail_execution(execution_arn, stop_error)
 
-        return StopDurableExecutionResponse(stop_date=datetime.now(UTC).isoformat())
+        return StopDurableExecutionResponse(end_timestamp=datetime.now(UTC).isoformat())
 
     def get_execution_state(
         self,

src/aws_durable_execution_sdk_python_testing/model.py

@@ -131,11 +131,11 @@ class GetDurableExecutionResponse:
     durable_execution_name: str
     function_arn: str
     status: str
-    start_date: str
+    start_timestamp: str
     input_payload: str | None = None
     result: str | None = None
     error: ErrorObject | None = None
-    stop_date: str | None = None
+    end_timestamp: str | None = None
     version: str | None = None
 
     @classmethod
@@ -149,11 +149,11 @@ def from_dict(cls, data: dict) -> GetDurableExecutionResponse:
             durable_execution_name=data["DurableExecutionName"],
             function_arn=data["FunctionArn"],
             status=data["Status"],
-            start_date=data["StartDate"],
+            start_timestamp=data["StartTimestamp"],
             input_payload=data.get("InputPayload"),
             result=data.get("Result"),
             error=error,
-            stop_date=data.get("StopDate"),
+            end_timestamp=data.get("EndTimestamp"),
             version=data.get("Version"),
         )
 
@@ -163,16 +163,18 @@ def to_dict(self) -> dict[str, Any]:
             "DurableExecutionName": self.durable_execution_name,
             "FunctionArn": self.function_arn,
             "Status": self.status,
-            "StartDate": self.start_date,
+            "StartTimestamp": self.start_timestamp,
         }
         if self.input_payload is not None:
             result["InputPayload"] = self.input_payload
         if self.result is not None:
             result["Result"] = self.result
         if self.error is not None:
             result["Error"] = self.error.to_dict()
-        if self.stop_date is not None:
-            result["StopDate"] = self.stop_date
+        if self.end_timestamp is not None:
+            result["EndTimestamp"] = self.end_timestamp
+        if self.end_timestamp is not None:
+            result["EndTimestamp"] = self.end_timestamp
         if self.version is not None:
             result["Version"] = self.version
         return result
@@ -186,8 +188,8 @@ class Execution:
     durable_execution_name: str
     function_arn: str
     status: str
-    start_date: str
-    stop_date: str | None = None
+    start_timestamp: str
+    end_timestamp: str | None = None
 
     @classmethod
     def from_dict(cls, data: dict) -> Execution:
@@ -198,21 +200,21 @@ def from_dict(cls, data: dict) -> Execution:
                 "FunctionArn", ""
             ),  # Make optional for backward compatibility
             status=data["Status"],
-            start_date=data["StartDate"],
-            stop_date=data.get("StopDate"),
+            start_timestamp=data["StartTimestamp"],
+            end_timestamp=data.get("EndTimestamp"),
         )
 
     def to_dict(self) -> dict[str, Any]:
         result = {
             "DurableExecutionArn": self.durable_execution_arn,
             "DurableExecutionName": self.durable_execution_name,
             "Status": self.status,
-            "StartDate": self.start_date,
+            "StartTimestamp": self.start_timestamp,
         }
         if self.function_arn:  # Only include if not empty
             result["FunctionArn"] = self.function_arn
-        if self.stop_date is not None:
-            result["StopDate"] = self.stop_date
+        if self.end_timestamp is not None:
+            result["EndTimestamp"] = self.end_timestamp
         return result
 
 
@@ -323,14 +325,14 @@ def to_dict(self) -> dict[str, Any]:
 class StopDurableExecutionResponse:
     """Response from stopping a durable execution."""
 
-    stop_date: str
+    end_timestamp: str
 
     @classmethod
     def from_dict(cls, data: dict) -> StopDurableExecutionResponse:
-        return cls(stop_date=data["StopDate"])
+        return cls(end_timestamp=data["EndTimestamp"])
 
     def to_dict(self) -> dict[str, Any]:
-        return {"StopDate": self.stop_date}
+        return {"EndTimestamp": self.end_timestamp}
 
 
 @dataclass(frozen=True)