Add change supporting unit testing

.github/workflows/validate.yml

@@ -31,4 +31,30 @@ jobs:
           flake8 . --count --show-source --statistics
       - name: Run tests
         run: |
-          pytest
+          pytest --ignore=samples-v2
+
+  test-samples:
+    strategy:
+      matrix:
+        app_name: [blueprint, fan_in_fan_out, function_chaining]
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: ./samples-v2/${{ matrix.app_name }}
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v2
+
+      - name: Set up Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: 3.9
+      - name: Install dependencies
+        run: |
+          python -m pip install --upgrade pip
+          pip install -r requirements.txt
+          pip install -r ../../requirements.txt
+          pip install ../.. --no-cache-dir --upgrade --no-deps --force-reinstall
+      - name: Run tests
+        run: |
+          python -m pytest

azure/durable_functions/decorators/durable_app.py

@@ -198,6 +198,17 @@ async def df_client_middleware(*args, **kwargs):
             # Invoke user code with rich DF Client binding
             return await user_code(*args, **kwargs)
 
+        # Todo: This feels awkward - however, there are two reasons that I can't naively implement
+        # this in the same way as entities and orchestrators:
+        # 1. We intentionally wrap this exported signature with @wraps, to preserve the original
+        #    signature of the user code. This means that we can't just assign a new object to the
+        #    fb._function._func, as that would overwrite the original signature.
+        # 2. I have not yet fully tested the behavior of overriding __call__ on an object with an
+        #    async method.
+        # Here we lose type hinting and auto-documentation - not great. Need to find a better way
+        # to do this.
+        df_client_middleware.client_function = fb._function._func
+
         user_code_with_rich_client = df_client_middleware
         fb._function._func = user_code_with_rich_client
 

azure/durable_functions/entity.py

@@ -3,13 +3,52 @@
 from datetime import datetime
 from typing import Callable, Any, List, Dict
 
+import azure.functions as func
+
 
 class InternalEntityException(Exception):
     """Framework-internal Exception class (for internal use only)."""
 
     pass
 
 
+class EntityHandler(Callable):
+    """Durable Entity Handler.
+
+    A callable class that wraps the user defined entity function for execution by the Python worker
+    and also allows access to the original method for unit testing
+    """
+
+    def __init__(self, func: Callable[[DurableEntityContext], None]):
+        """
+        Create a new entity handler for the user defined entity function.
+
+        Parameters
+        ----------
+        func: Callable[[DurableEntityContext], None]
+            The user defined entity function.
+        """
+        self.entity_function = func
+
+    def __call__(self, context: func.EntityContext) -> str:
+        """
+        Handle the execution of the user defined entity function.
+
+        Parameters
+        ----------
+        context : func.EntityContext
+            The DF entity context
+        """
+        # It is not clear when the context JSON would be found
+        # inside a "body"-key, but this pattern matches the
+        # orchestrator implementation, so we keep it for safety.
+        context_body = getattr(context, "body", None)
+        if context_body is None:
+            context_body = context
+        ctx, batch = DurableEntityContext.from_json(context_body)
+        return Entity(self.entity_function).handle(ctx, batch)
+
+
 class Entity:
     """Durable Entity Class.
 
@@ -92,19 +131,10 @@ def create(cls, fn: Callable[[DurableEntityContext], None]) -> Callable[[Any], s
 
         Returns
         -------
-        Callable[[Any], str]
-            Handle function of the newly created entity client
+        EntityHandler
+            Entity Handler callable for the newly created entity client
         """
-        def handle(context) -> str:
-            # It is not clear when the context JSON would be found
-            # inside a "body"-key, but this pattern matches the
-            # orchestrator implementation, so we keep it for safety.
-            context_body = getattr(context, "body", None)
-            if context_body is None:
-                context_body = context
-            ctx, batch = DurableEntityContext.from_json(context_body)
-            return Entity(fn).handle(ctx, batch)
-        return handle
+        return EntityHandler(fn)
 
     def _elapsed_milliseconds_since(self, start_time: datetime) -> int:
         """Calculate the elapsed time, in milliseconds, from the start_time to the present.

azure/durable_functions/orchestrator.py

@@ -11,6 +11,41 @@
 import azure.functions as func
 
 
+class OrchestrationHandler(Callable):
+    """Durable Orchestration Handler.
+
+    A callable class that wraps the user defined generator function for execution
+    by the Python worker and also allows access to the original method for unit testing
+    """
+
+    def __init__(self, func: Callable[[DurableOrchestrationContext], Generator[Any, Any, Any]]):
+        """
+        Create a new orchestrator handler for the user defined orchestrator function.
+
+        Parameters
+        ----------
+        func: Callable[[DurableOrchestrationContext], Generator[Any, Any, Any]]
+            The user defined orchestrator function.
+        """
+        self.orchestrator_function = func
+
+    def __call__(self, context: func.OrchestrationContext) -> str:
+        """
+        Handle the execution of the user defined orchestrator function.
+
+        Parameters
+        ----------
+        context : func.OrchestrationContext
+            The DF orchestration context
+        """
+        context_body = getattr(context, "body", None)
+        if context_body is None:
+            context_body = context
+        return Orchestrator(self.orchestrator_function).handle(
+            DurableOrchestrationContext.from_json(context_body)
+        )
+
+
 class Orchestrator:
     """Durable Orchestration Class.
 
@@ -58,14 +93,7 @@ def create(cls, fn: Callable[[DurableOrchestrationContext], Generator[Any, Any,
 
         Returns
         -------
-        Callable[[Any], str]
-            Handle function of the newly created orchestration client
+        OrchestrationHandler
+            Orchestration handler callable class for the newly created orchestration client
         """
-
-        def handle(context: func.OrchestrationContext) -> str:
-            context_body = getattr(context, "body", None)
-            if context_body is None:
-                context_body = context
-            return Orchestrator(fn).handle(DurableOrchestrationContext.from_json(context_body))
-
-        return handle
+        return OrchestrationHandler(fn)

samples-v2/blueprint/requirements.txt

@@ -3,4 +3,5 @@
 # Manually managing azure-functions-worker may cause unexpected issues
 
 azure-functions
-azure-functions-durable>=1.2.4
+azure-functions-durable>=1.2.4
+pytest

samples-v2/blueprint/tests/test_my_orchestrator.py

@@ -0,0 +1,58 @@
+from datetime import timedelta
+import unittest
+from unittest.mock import Mock, call, patch
+
+from durable_blueprints import my_orchestrator
+
+# A way to wrap an orchestrator generator to simplify calling it and getting the results.
+# Because orchestrators in Durable Functions always accept the result of the previous activity for the next send() call, 
+# we can simplify the orchestrator like this to also simplify per-test code. 
+def orchestrator_generator_wrapper(generator):
+  previous =  next(generator)
+  yield previous
+  while True:
+    try:
+      previous_result = None
+      try:
+        previous_result = previous.result
+      except Exception as e: # Simulated activity exceptions, timer interrupted exceptions, anytime a task would throw. 
+        previous = generator.throw(e)
+      else:
+        previous = generator.send(previous_result)      
+      yield previous
+    except StopIteration as e:
+      yield e.value
+      return
+
+
+class MockTask():
+  def __init__(self, result=None):
+    self.result = result
+
+
+def mock_activity(activity_name, input):
+  if activity_name == "say_hello":
+    return MockTask(f"Hello {input}!")
+  raise Exception("Activity not found")
+
+
+class TestFunction(unittest.TestCase):
+  @patch('azure.durable_functions.DurableOrchestrationContext')
+  def test_chaining_orchestrator(self, context):
+    # Get the original method definition as seen in the function_app.py file
+    func_call = my_orchestrator.build().get_user_function().orchestrator_function
+
+    context.call_activity = Mock(side_effect=mock_activity)
+    # Create a generator using the method and mocked context
+    user_orchestrator = func_call(context)
+
+    # Use a method defined above to get the values from the generator. Quick unwrap for easy access
+    values = [val for val in orchestrator_generator_wrapper(user_orchestrator)]
+
+    expected_activity_calls = [call('say_hello', 'Tokyo'),
+                               call('say_hello', 'Seattle'),
+                               call('say_hello', 'London')]
+
+    self.assertEqual(context.call_activity.call_count, 3)
+    self.assertEqual(context.call_activity.call_args_list, expected_activity_calls)
+    self.assertEqual(values[3], ["Hello Tokyo!", "Hello Seattle!", "Hello London!"])

samples-v2/fan_in_fan_out/requirements.txt

@@ -4,4 +4,5 @@
 
 azure-functions
 azure-functions-durable
-azure-storage-blob
+azure-storage-blob
+pytest

samples-v2/fan_in_fan_out/tests/test_E2_BackupSiteContent.py

@@ -0,0 +1,63 @@
+import unittest
+from unittest.mock import Mock, call, patch
+
+from function_app import E2_BackupSiteContent
+
+# A way to wrap an orchestrator generator to simplify calling it and getting the results.
+# Because orchestrators in Durable Functions always accept the result of the previous activity for the next send() call, 
+# we can simplify the orchestrator like this to also simplify per-test code. 
+def orchestrator_generator_wrapper(generator):
+  previous =  next(generator)
+  yield previous
+  while True:
+    try:
+      previous_result = None
+      try:
+        previous_result = previous.result
+      except Exception as e: # Simulated activity exceptions, timer interrupted exceptions, anytime a task would throw. 
+        previous = generator.throw(e)
+      else:
+        previous = generator.send(previous_result)      
+      yield previous
+    except StopIteration as e:
+      yield e.value
+      return
+
+
+class MockTask():
+  def __init__(self, result=None):
+    self.result = result
+
+
+def mock_activity(activity_name, input):
+  if activity_name == "E2_GetFileList":
+    return MockTask(["C:/test/E2_Activity.py", "C:/test/E2_Orchestrator.py"])
+  return MockTask(input)
+
+
+class TestFunction(unittest.TestCase):
+  @patch('azure.durable_functions.DurableOrchestrationContext')
+  def test_E2_BackupSiteContent(self, context):
+    # Get the original method definition as seen in the function_app.py file
+    func_call = E2_BackupSiteContent.build().get_user_function().orchestrator_function
+
+    context.get_input = Mock(return_value="C:/test")
+    context.call_activity = Mock(side_effect=mock_activity)
+    context.task_all = Mock(return_value=MockTask([100, 200, 300]))
+
+    # Create a generator using the method and mocked context
+    user_orchestrator = func_call(context)
+
+    # Use a method defined above to get the values from the generator. Quick unwrap for easy access
+    values = [val for val in orchestrator_generator_wrapper(user_orchestrator)]
+
+    expected_activity_calls = [call('E2_GetFileList', 'C:/test'),
+                               call('E2_CopyFileToBlob', 'C:/test/E2_Activity.py'),
+                               call('E2_CopyFileToBlob', 'C:/test/E2_Orchestrator.py')]
+
+    self.assertEqual(context.call_activity.call_count, 3)
+    self.assertEqual(context.call_activity.call_args_list, expected_activity_calls)
+
+    context.task_all.assert_called_once()
+    # Sums the result of task_all
+    self.assertEqual(values[2], 600)

samples-v2/fan_in_fan_out/tests/test_E2_CopyFileToBlob.py

@@ -0,0 +1 @@
+# Stub file - test this function with standard Azure Functions Python testing tools. 

samples-v2/fan_in_fan_out/tests/test_E2_GetFileList.py

@@ -0,0 +1 @@
+# Stub file - test this function with standard Azure Functions Python testing tools. 

samples-v2/fan_in_fan_out/tests/test_HttpStart.py

@@ -0,0 +1,28 @@
+import asyncio
+import unittest
+import azure.functions as func
+from unittest.mock import AsyncMock, Mock, patch
+
+from function_app import HttpStart
+
+class TestFunction(unittest.TestCase):
+  @patch('azure.durable_functions.DurableOrchestrationClient')
+  def test_HttpStart(self, client):
+    # Get the original method definition as seen in the function_app.py file
+    # func_call = chaining_orchestrator.build().get_user_function_unmodified()
+    func_call = HttpStart.build().get_user_function().client_function
+
+    req = func.HttpRequest(method='GET',
+                           body=b'{}',
+                           url='/api/my_second_function',
+                           route_params={"functionName": "E2_BackupSiteContent"})
+
+    client.start_new = AsyncMock(return_value="instance_id")
+    client.create_check_status_response = Mock(return_value="check_status_response")
+
+    # Create a generator using the method and mocked context
+    result = asyncio.run(func_call(req, client))
+
+    client.start_new.assert_called_once_with("E2_BackupSiteContent", client_input={})
+    client.create_check_status_response.assert_called_once_with(req, "instance_id")
+    self.assertEqual(result, "check_status_response")

samples-v2/function_chaining/requirements.txt

@@ -4,3 +4,4 @@
 
 azure-functions
 azure-functions-durable
+pytest