azure-functions-durable 1.2.9__py3-none-any.whl → 1.3.0__py3-none-any.whl

tests/tasks/tasks_test_utils.py

@@ -1,17 +1,17 @@
-def assert_tasks_equal(task1, task2):
-    assert task1.is_completed == task2.is_completed
-    assert task1.is_faulted == task2.is_faulted
-    assert task1.result == task2.result
-    assert task1.timestamp == task2.timestamp
-    assert task1.id == task2.id
-    assert task1.action == task2.action
-    assert str(task1.exception) == str(task2.exception)
-
-
-def assert_taskset_equal(taskset1, taskset2):
-    assert taskset1.is_completed == taskset2.is_completed
-    assert taskset1.is_faulted == taskset2.is_faulted
-    assert taskset1.result == taskset2.result
-    assert taskset1.actions == taskset2.actions
-    assert taskset1.timestamp == taskset2.timestamp
-    assert str(taskset1.exception) == str(taskset2.exception)
+def assert_tasks_equal(task1, task2):
+    assert task1.is_completed == task2.is_completed
+    assert task1.is_faulted == task2.is_faulted
+    assert task1.result == task2.result
+    assert task1.timestamp == task2.timestamp
+    assert task1.id == task2.id
+    assert task1.action == task2.action
+    assert str(task1.exception) == str(task2.exception)
+
+
+def assert_taskset_equal(taskset1, taskset2):
+    assert taskset1.is_completed == taskset2.is_completed
+    assert taskset1.is_faulted == taskset2.is_faulted
+    assert taskset1.result == taskset2.result
+    assert taskset1.actions == taskset2.actions
+    assert taskset1.timestamp == taskset2.timestamp
+    assert str(taskset1.exception) == str(taskset2.exception)

tests/tasks/test_long_timers.py

@@ -0,0 +1,70 @@
+import datetime
+
+import pytest
+from azure.durable_functions.models.DurableOrchestrationContext import DurableOrchestrationContext
+from azure.durable_functions.models.Task import LongTimerTask, TaskState, TimerTask
+from azure.durable_functions.models.actions.CreateTimerAction import CreateTimerAction
+
+
+@pytest.fixture
+def starting_context_v3():
+    context = DurableOrchestrationContext.from_json(
+        '{"history":[{"EventType":12,"EventId":-1,"IsPlayed":false,'
+        '"Timestamp":"'
+        f'{datetime.datetime.now(datetime.timezone.utc).isoformat()}'
+        '"}, {"OrchestrationInstance":{'
+        '"InstanceId":"48d0f95957504c2fa579e810a390b938", '
+        '"ExecutionId":"fd183ee02e4b4fd18c95b773cfb5452b"},"EventType":0,'
+        '"ParentInstance":null, '
+        '"Name":"DurableOrchestratorTrigger","Version":"","Input":"null",'
+        '"Tags":null,"EventId":-1,"IsPlayed":false, '
+        '"Timestamp":"'
+        f'{datetime.datetime.now(datetime.timezone.utc).isoformat()}'
+        '"}],"input":null,'
+        '"instanceId":"48d0f95957504c2fa579e810a390b938", '
+        '"upperSchemaVersion": 2, '
+        '"upperSchemaVersionNew": 3, '
+        '"isReplaying":false,"parentInstanceId":null, '
+        '"maximumShortTimerDuration":"0.16:00:00", '
+        '"longRunningTimerIntervalDuration":"0.08:00:00" } ')
+    return context
+
+
+def test_durable_context_creates_correct_timer(starting_context_v3):
+    timer = starting_context_v3.create_timer(datetime.datetime.now(datetime.timezone.utc) +
+                                             datetime.timedelta(minutes=30))
+    assert isinstance(timer, TimerTask)
+
+    timer2 = starting_context_v3.create_timer(datetime.datetime.now(datetime.timezone.utc) +
+                                              datetime.timedelta(days=1))
+    assert isinstance(timer2, LongTimerTask)
+
+def test_long_timer_fires_appropriately(starting_context_v3):
+    starting_time = starting_context_v3.current_utc_datetime
+    final_fire_time = starting_time + datetime.timedelta(hours=20)
+    long_timer_action = CreateTimerAction(final_fire_time)
+    long_timer = LongTimerTask(None, long_timer_action, starting_context_v3)
+    assert long_timer.action.fire_at == final_fire_time
+    assert long_timer.action == long_timer_action
+
+    # Check the first "inner" timer and simulate firing it
+    short_timer = long_timer.pending_tasks.pop()
+    assert short_timer.action_repr.fire_at == starting_time + datetime.timedelta(hours=8)
+    # This happens when the task is reconstructed during replay, doing it manually for the test
+    long_timer._orchestration_context.current_utc_datetime = short_timer.action_repr.fire_at
+    short_timer.state = TaskState.SUCCEEDED 
+    long_timer.try_set_value(short_timer)
+
+    assert long_timer.state == TaskState.RUNNING
+
+    # Check the scond "inner" timer and simulate firing it. This one should be set to the final
+    # fire time, the remaining time (12 hours) is less than the max long timer duration (16 hours)
+    short_timer = long_timer.pending_tasks.pop()
+    assert short_timer.action_repr.fire_at == final_fire_time
+    long_timer._orchestration_context.current_utc_datetime = short_timer.action_repr.fire_at
+    short_timer.state = TaskState.SUCCEEDED 
+    long_timer.try_set_value(short_timer)
+
+    # Ensure the LongTimerTask finished
+    assert len(long_timer.pending_tasks) == 0
+    assert long_timer.state == TaskState.SUCCEEDED

tests/tasks/test_new_uuid.py

@@ -1,35 +1,35 @@
-from uuid import uuid1
-from typing import List, Any, Dict
-from azure.durable_functions.models.DurableOrchestrationContext import DurableOrchestrationContext
-from azure.durable_functions.constants import DATETIME_STRING_FORMAT
-
-
-def history_list() -> List[Dict[Any, Any]]:
-    history = [{'EventType': 12, 'EventId': -1, 'IsPlayed': False,
-                'Timestamp': '2019-12-08T23:18:41.3240927Z'}, {
-                   'OrchestrationInstance': {'InstanceId': '48d0f95957504c2fa579e810a390b938',
-                                             'ExecutionId': 'fd183ee02e4b4fd18c95b773cfb5452b'},
-                   'EventType': 0, 'ParentInstance': None, 'Name': 'DurableOrchestratorTrigger',
-                   'Version': '', 'Input': 'null', 'Tags': None, 'EventId': -1, 'IsPlayed': False,
-                   'Timestamp': '2019-12-08T23:18:39.756132Z'}]
-    return history
-
-
-def test_new_uuid():
-    instance_id = str(uuid1())
-    history = history_list()
-    context1 = DurableOrchestrationContext(history, instance_id, False, None)
-
-    result1a = context1.new_uuid()
-    result1b = context1.new_uuid()
-
-    context2 = DurableOrchestrationContext(history, instance_id, False, None)
-
-    result2a = context2.new_uuid()
-    result2b = context2.new_uuid()
-
-    assert result1a == result2a
-    assert result1b == result2b
-
-    assert result1a != result1b
+from uuid import uuid1
+from typing import List, Any, Dict
+from azure.durable_functions.models.DurableOrchestrationContext import DurableOrchestrationContext
+from azure.durable_functions.constants import DATETIME_STRING_FORMAT
+
+
+def history_list() -> List[Dict[Any, Any]]:
+    history = [{'EventType': 12, 'EventId': -1, 'IsPlayed': False,
+                'Timestamp': '2019-12-08T23:18:41.3240927Z'}, {
+                   'OrchestrationInstance': {'InstanceId': '48d0f95957504c2fa579e810a390b938',
+                                             'ExecutionId': 'fd183ee02e4b4fd18c95b773cfb5452b'},
+                   'EventType': 0, 'ParentInstance': None, 'Name': 'DurableOrchestratorTrigger',
+                   'Version': '', 'Input': 'null', 'Tags': None, 'EventId': -1, 'IsPlayed': False,
+                   'Timestamp': '2019-12-08T23:18:39.756132Z'}]
+    return history
+
+
+def test_new_uuid():
+    instance_id = str(uuid1())
+    history = history_list()
+    context1 = DurableOrchestrationContext(history, instance_id, False, None)
+
+    result1a = context1.new_uuid()
+    result1b = context1.new_uuid()
+
+    context2 = DurableOrchestrationContext(history, instance_id, False, None)
+
+    result2a = context2.new_uuid()
+    result2b = context2.new_uuid()
+
+    assert result1a == result2a
+    assert result1b == result2b
+
+    assert result1a != result1b
     assert result2a != result2b

tests/test_utils/ContextBuilder.py

@@ -1,174 +1,174 @@
-from azure.durable_functions.models.ReplaySchema import ReplaySchema
-import uuid
-import json
-from datetime import datetime, timedelta
-from typing import List, Dict, Any, Optional
-
-from .json_utils import add_attrib, convert_history_event_to_json_dict
-from azure.durable_functions.constants import DATETIME_STRING_FORMAT
-from tests.orchestrator.models.OrchestrationInstance \
-    import OrchestrationInstance
-from azure.durable_functions.models.history.HistoryEvent import HistoryEvent
-from azure.durable_functions.models.history.HistoryEventType \
-    import HistoryEventType
-
-
-class ContextBuilder:
-    def __init__(self, name: str="", increase_time: bool = True, starting_time: Optional[datetime] = None, is_replaying=False, replay_schema: ReplaySchema = ReplaySchema.V1):
-        self.increase_time = increase_time
-        self.instance_id = uuid.uuid4()
-        self.is_replaying: bool = False
-        self.input_ = None
-        self.parent_instance_id = None
-        self.history_events: List[HistoryEvent] = []
-
-        if starting_time is None:
-            starting_time = datetime.now()
-        self.current_datetime: datetime = starting_time
-        self.upperSchemaVersion = replay_schema.value
-
-        self.add_orchestrator_started_event()
-        self.add_execution_started_event(name, is_played=is_replaying)
-
-    def get_base_event(
-            self, event_type: HistoryEventType, id_: int = -1,
-            is_played: bool = False, timestamp=None) -> HistoryEvent:
-        if self.increase_time:
-            self.current_datetime = self.current_datetime + timedelta(seconds=1)
-        if not timestamp:
-            timestamp = self.current_datetime
-        event = HistoryEvent(EventType=event_type, EventId=id_,
-                             IsPlayed=is_played,
-                             Timestamp=timestamp.strftime(DATETIME_STRING_FORMAT))
-
-        return event
-
-    def add_orchestrator_started_event(self):
-        event = self.get_base_event(HistoryEventType.ORCHESTRATOR_STARTED)
-        self.history_events.append(event)
-
-    def add_orchestrator_completed_event(self):
-        event = self.get_base_event(HistoryEventType.ORCHESTRATOR_COMPLETED)
-        self.history_events.append(event)
-
-    def add_sub_orchestrator_started_event(self, name: str, id_, input_=None):
-        event = self.get_base_event(HistoryEventType.SUB_ORCHESTRATION_INSTANCE_CREATED,
-            id_=id_)
-        event.Name = name
-        event.Input = input_
-        self.history_events.append(event)
-
-    def add_sub_orchestrator_completed_event(self, result, id_):
-        event = self.get_base_event(HistoryEventType.SUB_ORCHESTRATION_INSTANCE_COMPLETED)
-        event.Result = result
-        event.TaskScheduledId = id_
-        self.history_events.append(event)
-
-    def add_sub_orchestrator_failed_event(self, id_, reason, details):
-        event = self.get_base_event(HistoryEventType.SUB_ORCHESTRATION_INSTANCE_FAILED)
-        event.Reason = reason
-        event.Details = details
-        event.TaskScheduledId = id_
-        self.history_events.append(event)
-
-    def add_event_sent_event(self, instance_id, event_id):
-        event = self.get_base_event(HistoryEventType.EVENT_SENT)
-        event.InstanceId = instance_id
-        event._event_id = event_id
-        event.Name = "op"
-        event.Input = json.dumps({ "id": "0000" }) # usually provided by the extension
-        self.history_events.append(event)
-
-    def add_task_scheduled_event(
-            self, name: str, id_: int, version: str = '', input_=None):
-        event = self.get_base_event(HistoryEventType.TASK_SCHEDULED, id_=id_)
-        event.Name = name
-        event.Version = version
-        event.Input_ = input_
-        self.history_events.append(event)
-
-    def add_task_completed_event(self, id_: int, result, is_played=False):
-        event = self.get_base_event(HistoryEventType.TASK_COMPLETED, is_played=is_played)
-        event.Result = result
-        event.TaskScheduledId = id_
-        self.history_events.append(event)
-
-    def add_task_failed_event(self, id_: int, reason: str, details: str):
-        event = self.get_base_event(HistoryEventType.TASK_FAILED)
-        event.Reason = reason
-        event.Details = details
-        event.TaskScheduledId = id_
-        self.history_events.append(event)
-
-    def add_timer_created_event(self, id_: int, timestamp: str = None):
-        fire_at = self.current_datetime.strftime(DATETIME_STRING_FORMAT)
-        if timestamp is not None:
-            fire_at = timestamp
-        event = self.get_base_event(HistoryEventType.TIMER_CREATED, id_=id_)
-        event.FireAt = fire_at
-        self.history_events.append(event)
-        return fire_at
-
-    def add_timer_fired_event(self, id_: int, fire_at: str, is_played: bool = True):
-        event = self.get_base_event(HistoryEventType.TIMER_FIRED, is_played=is_played)
-        event.TimerId = id_
-        event.FireAt = fire_at
-        self.history_events.append(event)
-
-    def add_execution_started_event(
-            self, name: str, version: str = '', input_=None, is_played=True):
-        event = self.get_base_event(HistoryEventType.EXECUTION_STARTED, is_played=is_played)
-        event.orchestration_instance = OrchestrationInstance()
-        self.instance_id = event.orchestration_instance.instance_id
-        event.Name = name
-        event.Version = version
-        event.Input = input_
-        self.history_events.append(event)
-
-    def add_event_raised_event(self, name:str, id_: int, input_=None, timestamp=None, is_entity=False, is_error = False, literal_input=False):
-        event = self.get_base_event(HistoryEventType.EVENT_RAISED, id_=id_, timestamp=timestamp)
-        event.Name = name
-        if is_entity:
-            if is_error:
-                event.Input = json.dumps({ "result": json.dumps(input_), "exceptionType": "True" })
-            else:
-                if literal_input:
-                    event.Input = json.dumps({ "result": input_ })
-                else:
-                    event.Input = json.dumps({ "result": json.dumps(input_) })
-        else:
-            event.Input = input_
-        # event.timestamp = timestamp
-        self.history_events.append(event)
-
-    def to_json(self, **kwargs) -> Dict[str, Any]:
-        json_dict = {}
-
-        add_attrib(json_dict, self, 'instance_id', 'instanceId')
-        add_attrib(json_dict, self, 'parent_instance_id', 'parentInstanceId')
-        add_attrib(json_dict, self, 'is_replaying', 'isReplaying')
-        add_attrib(json_dict, self, 'input_', "input")
-        add_attrib(json_dict, self, 'upperSchemaVersion', "upperSchemaVersion")
-
-        history_list_as_dict = self.get_history_list_as_dict()
-        json_dict['history'] = history_list_as_dict
-
-        if kwargs is not None:
-            for key, value in kwargs.items():
-                json_dict[key] = value
-
-        return json_dict
-
-    def get_history_list_as_dict(self) -> List[Dict[str, Any]]:
-        history_list = []
-
-        for history_event in self.history_events:
-            event_as_dict = convert_history_event_to_json_dict(history_event)
-            history_list.append(event_as_dict)
-
-        return history_list
-
-    def to_json_string(self, **kwargs) -> str:
-        json_dict = self.to_json(**kwargs)
-
-        return json.dumps(json_dict)
+from azure.durable_functions.models.ReplaySchema import ReplaySchema
+import uuid
+import json
+from datetime import datetime, timedelta
+from typing import List, Dict, Any, Optional
+
+from .json_utils import add_attrib, convert_history_event_to_json_dict
+from azure.durable_functions.constants import DATETIME_STRING_FORMAT
+from tests.orchestrator.models.OrchestrationInstance \
+    import OrchestrationInstance
+from azure.durable_functions.models.history.HistoryEvent import HistoryEvent
+from azure.durable_functions.models.history.HistoryEventType \
+    import HistoryEventType
+
+
+class ContextBuilder:
+    def __init__(self, name: str="", increase_time: bool = True, starting_time: Optional[datetime] = None, is_replaying=False, replay_schema: ReplaySchema = ReplaySchema.V1):
+        self.increase_time = increase_time
+        self.instance_id = uuid.uuid4()
+        self.is_replaying: bool = False
+        self.input_ = None
+        self.parent_instance_id = None
+        self.history_events: List[HistoryEvent] = []
+
+        if starting_time is None:
+            starting_time = datetime.now()
+        self.current_datetime: datetime = starting_time
+        self.upperSchemaVersion = replay_schema.value
+
+        self.add_orchestrator_started_event()
+        self.add_execution_started_event(name, is_played=is_replaying)
+
+    def get_base_event(
+            self, event_type: HistoryEventType, id_: int = -1,
+            is_played: bool = False, timestamp=None) -> HistoryEvent:
+        if self.increase_time:
+            self.current_datetime = self.current_datetime + timedelta(seconds=1)
+        if not timestamp:
+            timestamp = self.current_datetime
+        event = HistoryEvent(EventType=event_type, EventId=id_,
+                             IsPlayed=is_played,
+                             Timestamp=timestamp.strftime(DATETIME_STRING_FORMAT))
+
+        return event
+
+    def add_orchestrator_started_event(self):
+        event = self.get_base_event(HistoryEventType.ORCHESTRATOR_STARTED)
+        self.history_events.append(event)
+
+    def add_orchestrator_completed_event(self):
+        event = self.get_base_event(HistoryEventType.ORCHESTRATOR_COMPLETED)
+        self.history_events.append(event)
+
+    def add_sub_orchestrator_started_event(self, name: str, id_, input_=None):
+        event = self.get_base_event(HistoryEventType.SUB_ORCHESTRATION_INSTANCE_CREATED,
+            id_=id_)
+        event.Name = name
+        event.Input = input_
+        self.history_events.append(event)
+
+    def add_sub_orchestrator_completed_event(self, result, id_):
+        event = self.get_base_event(HistoryEventType.SUB_ORCHESTRATION_INSTANCE_COMPLETED)
+        event.Result = result
+        event.TaskScheduledId = id_
+        self.history_events.append(event)
+
+    def add_sub_orchestrator_failed_event(self, id_, reason, details):
+        event = self.get_base_event(HistoryEventType.SUB_ORCHESTRATION_INSTANCE_FAILED)
+        event.Reason = reason
+        event.Details = details
+        event.TaskScheduledId = id_
+        self.history_events.append(event)
+
+    def add_event_sent_event(self, instance_id, event_id):
+        event = self.get_base_event(HistoryEventType.EVENT_SENT)
+        event.InstanceId = instance_id
+        event._event_id = event_id
+        event.Name = "op"
+        event.Input = json.dumps({ "id": "0000" }) # usually provided by the extension
+        self.history_events.append(event)
+
+    def add_task_scheduled_event(
+            self, name: str, id_: int, version: str = '', input_=None):
+        event = self.get_base_event(HistoryEventType.TASK_SCHEDULED, id_=id_)
+        event.Name = name
+        event.Version = version
+        event.Input_ = input_
+        self.history_events.append(event)
+
+    def add_task_completed_event(self, id_: int, result, is_played=False):
+        event = self.get_base_event(HistoryEventType.TASK_COMPLETED, is_played=is_played)
+        event.Result = result
+        event.TaskScheduledId = id_
+        self.history_events.append(event)
+
+    def add_task_failed_event(self, id_: int, reason: str, details: str):
+        event = self.get_base_event(HistoryEventType.TASK_FAILED)
+        event.Reason = reason
+        event.Details = details
+        event.TaskScheduledId = id_
+        self.history_events.append(event)
+
+    def add_timer_created_event(self, id_: int, timestamp: str = None):
+        fire_at = self.current_datetime.strftime(DATETIME_STRING_FORMAT)
+        if timestamp is not None:
+            fire_at = timestamp
+        event = self.get_base_event(HistoryEventType.TIMER_CREATED, id_=id_)
+        event.FireAt = fire_at
+        self.history_events.append(event)
+        return fire_at
+
+    def add_timer_fired_event(self, id_: int, fire_at: str, is_played: bool = True):
+        event = self.get_base_event(HistoryEventType.TIMER_FIRED, is_played=is_played)
+        event.TimerId = id_
+        event.FireAt = fire_at
+        self.history_events.append(event)
+
+    def add_execution_started_event(
+            self, name: str, version: str = '', input_=None, is_played=True):
+        event = self.get_base_event(HistoryEventType.EXECUTION_STARTED, is_played=is_played)
+        event.orchestration_instance = OrchestrationInstance()
+        self.instance_id = event.orchestration_instance.instance_id
+        event.Name = name
+        event.Version = version
+        event.Input = input_
+        self.history_events.append(event)
+
+    def add_event_raised_event(self, name:str, id_: int, input_=None, timestamp=None, is_entity=False, is_error = False, literal_input=False):
+        event = self.get_base_event(HistoryEventType.EVENT_RAISED, id_=id_, timestamp=timestamp)
+        event.Name = name
+        if is_entity:
+            if is_error:
+                event.Input = json.dumps({ "result": json.dumps(input_), "exceptionType": "True" })
+            else:
+                if literal_input:
+                    event.Input = json.dumps({ "result": input_ })
+                else:
+                    event.Input = json.dumps({ "result": json.dumps(input_) })
+        else:
+            event.Input = input_
+        # event.timestamp = timestamp
+        self.history_events.append(event)
+
+    def to_json(self, **kwargs) -> Dict[str, Any]:
+        json_dict = {}
+
+        add_attrib(json_dict, self, 'instance_id', 'instanceId')
+        add_attrib(json_dict, self, 'parent_instance_id', 'parentInstanceId')
+        add_attrib(json_dict, self, 'is_replaying', 'isReplaying')
+        add_attrib(json_dict, self, 'input_', "input")
+        add_attrib(json_dict, self, 'upperSchemaVersion', "upperSchemaVersion")
+
+        history_list_as_dict = self.get_history_list_as_dict()
+        json_dict['history'] = history_list_as_dict
+
+        if kwargs is not None:
+            for key, value in kwargs.items():
+                json_dict[key] = value
+
+        return json_dict
+
+    def get_history_list_as_dict(self) -> List[Dict[str, Any]]:
+        history_list = []
+
+        for history_event in self.history_events:
+            event_as_dict = convert_history_event_to_json_dict(history_event)
+            history_list.append(event_as_dict)
+
+        return history_list
+
+    def to_json_string(self, **kwargs) -> str:
+        json_dict = self.to_json(**kwargs)
+
+        return json.dumps(json_dict)

tests/test_utils/EntityContextBuilder.py

@@ -1,57 +1,57 @@
-import json
-from typing import Any, List, Dict, Any
-
-class EntityContextBuilder():
-    """Mock class for an EntityContext object, includes a batch field for convenience
-    """
-    def __init__(self,
-                 name: str = "",
-                 key: str = "",
-                 exists: bool = True,
-                 state: Any = None,
-                 batch: List[Dict[str, Any]] = []):
-        """Construct an EntityContextBuilder
-
-        Parameters
-        ----------
-        name: str:
-            The name of the entity. Defaults to the empty string.
-        key: str
-            The key of the entity. Defaults to the empty string.
-        exists: bool
-            Boolean representing if the entity exists, defaults to True.
-        state: Any
-            The state of the entity, defaults ot None.
-        batch: List[Dict[str, Any]]
-            The upcoming batch of operations for the entity to perform.
-            Note that the batch is not technically a part of the entity context
-            and so it is here only for convenience. Defaults to the empty list.
-        """
-        self.name = name
-        self.key = key
-        self.exists = exists
-        self.state = state
-        self.batch = batch
-    
-    def to_json_string(self) -> str:
-        """Generate a string-representation of the Entity input payload.
-
-        The payload matches the current durable-extension entity-communication
-        schema.
-
-        Returns
-        -------
-        str:
-            A JSON-formatted string for an EntityContext to load via `from_json`
-        """
-        context_json = {
-            "self": {
-                "name": self.name,
-                "key": self.key
-            },
-            "state": self.state,
-            "exists": self.exists,
-            "batch": self.batch
-        }
-        json_string = json.dumps(context_json)
+import json
+from typing import Any, List, Dict, Any
+
+class EntityContextBuilder():
+    """Mock class for an EntityContext object, includes a batch field for convenience
+    """
+    def __init__(self,
+                 name: str = "",
+                 key: str = "",
+                 exists: bool = True,
+                 state: Any = None,
+                 batch: List[Dict[str, Any]] = []):
+        """Construct an EntityContextBuilder
+
+        Parameters
+        ----------
+        name: str:
+            The name of the entity. Defaults to the empty string.
+        key: str
+            The key of the entity. Defaults to the empty string.
+        exists: bool
+            Boolean representing if the entity exists, defaults to True.
+        state: Any
+            The state of the entity, defaults ot None.
+        batch: List[Dict[str, Any]]
+            The upcoming batch of operations for the entity to perform.
+            Note that the batch is not technically a part of the entity context
+            and so it is here only for convenience. Defaults to the empty list.
+        """
+        self.name = name
+        self.key = key
+        self.exists = exists
+        self.state = state
+        self.batch = batch
+    
+    def to_json_string(self) -> str:
+        """Generate a string-representation of the Entity input payload.
+
+        The payload matches the current durable-extension entity-communication
+        schema.
+
+        Returns
+        -------
+        str:
+            A JSON-formatted string for an EntityContext to load via `from_json`
+        """
+        context_json = {
+            "self": {
+                "name": self.name,
+                "key": self.key
+            },
+            "state": self.state,
+            "exists": self.exists,
+            "batch": self.batch
+        }
+        json_string = json.dumps(context_json)
         return json_string

tests/test_utils/constants.py

@@ -1 +1 @@
-RPC_BASE_URL = "http://127.0.0.1:17071/durabletask/"
+RPC_BASE_URL = "http://127.0.0.1:17071/durabletask/"