Added more unit tests

Author: gavin-aguiar

azure_functions_worker/constants.py

@@ -57,4 +57,4 @@
 CUSTOMER_PACKAGES_PATH = "/home/site/wwwroot/.python_packages/lib/site-packages"
 
 # Flag to index functions in handle init request
-INIT_INDEXING = "INIT_INDEXING"
+ENABLE_INIT_INDEXING = "ENABLE_INIT_INDEXING"

azure_functions_worker/dispatcher.py

@@ -30,7 +30,7 @@
                         PYTHON_ENABLE_DEBUG_LOGGING,
                         PYTHON_SCRIPT_FILE_NAME,
                         PYTHON_SCRIPT_FILE_NAME_DEFAULT,
-                        PYTHON_LANGUAGE_RUNTIME, INIT_INDEXING)
+                        PYTHON_LANGUAGE_RUNTIME, ENABLE_INIT_INDEXING)
 from .extension import ExtensionManager
 from .logging import disable_console_logging, enable_console_logging
 from .logging import (logger, error_logger, is_system_log_category,
@@ -301,7 +301,7 @@ async def _handle__worker_init_request(self, request):
         # dictionary which will be later used in the invocation request
         bindings.load_binding_registry()
 
-        if is_envvar_true(INIT_INDEXING):
+        if is_envvar_true(ENABLE_INIT_INDEXING):
             self.get_function_metadata(directory,
                                        caller_info=sys._getframe().f_code.co_name)
 
@@ -322,6 +322,11 @@ async def _handle__worker_status_request(self, request):
             worker_status_response=protos.WorkerStatusResponse())
 
     def get_function_metadata(self, directory, caller_info):
+        """
+        This method is called to index the functions in the function app directory
+        and save the results in function_metadata_result or 
+        function_metadata_exception in case of an exception. 
+        """
         script_file_name = get_app_setting(
             setting=PYTHON_SCRIPT_FILE_NAME,
             default_value=f'{PYTHON_SCRIPT_FILE_NAME_DEFAULT}')
@@ -345,7 +350,7 @@ async def _handle__functions_metadata_request(self, request):
         metadata_request = request.functions_metadata_request
         directory = metadata_request.function_app_directory
 
-        if not is_envvar_true(INIT_INDEXING):
+        if not is_envvar_true(ENABLE_INIT_INDEXING):
             self.get_function_metadata(directory,
                                        caller_info=sys._getframe().f_code.co_name)
 
@@ -383,7 +388,7 @@ async def _handle__function_load_request(self, request):
             if not self._functions.get_function(function_id):
 
                 if function_metadata.properties.get("worker_indexed", False)\
-                        and not is_envvar_true(INIT_INDEXING):
+                        and not is_envvar_true(ENABLE_INIT_INDEXING):
                     # This is for the second worker and above where the worker
                     # indexing is enabled and load request is called without
                     # calling the metadata request. In this case we index the

azure_functions_worker/loader.py

@@ -218,6 +218,7 @@ def load_function(name: str, directory: str, script_file: str,
                f'{os.path.exists(CUSTOMER_PACKAGES_PATH)}')
 def index_function_app(function_path: str):
     module_name = pathlib.Path(function_path).stem
+    logger.info(f'Loading module {module_name}')
     imported_module = importlib.import_module(module_name)
 
     from azure.functions import FunctionRegister

tests/endtoend/test_http_functions.py

@@ -34,7 +34,8 @@ def tearDown(self):
 
     @classmethod
     def get_script_dir(cls):
-        return testutils.E2E_TESTS_FOLDER / 'http_functions'
+        return testutils.E2E_TESTS_FOLDER / 'http_functions' / \
+            'http_functions_stein'
 
     @testutils.retryable_test(3, 5)
     def test_function_index_page_should_return_ok(self):

tests/unittests/dispatcher_functions/dispatcher_functions_stein/function_app.py

@@ -1,8 +1,9 @@
 import azure.functions as func
 
-app = func.FunctionApp()
+app = func.FunctionApp(http_auth_level=func.AuthLevel.ANONYMOUS)
 
 
-@app.route()
-def main(req: func.HttpRequest):
-    pass
+@app.route(route="http_trigger")
+def http_trigger(req: func.HttpRequest) -> func.HttpResponse:
+
+    return func.HttpResponse("Hello.")

tests/unittests/test_dispatcher.py

@@ -11,7 +11,7 @@
 from azure_functions_worker import protos
 from azure_functions_worker.constants import PYTHON_THREADPOOL_THREAD_COUNT, \
     PYTHON_THREADPOOL_THREAD_COUNT_DEFAULT, \
-    PYTHON_THREADPOOL_THREAD_COUNT_MAX_37, PYTHON_THREADPOOL_THREAD_COUNT_MIN
+    PYTHON_THREADPOOL_THREAD_COUNT_MAX_37, PYTHON_THREADPOOL_THREAD_COUNT_MIN, ENABLE_INIT_INDEXING
 from azure_functions_worker.version import VERSION
 from tests.utils import testutils
 from tests.utils.testutils import UNIT_TESTS_ROOT
@@ -22,8 +22,8 @@
 DISPATCHER_STEIN_FUNCTIONS_DIR = testutils.UNIT_TESTS_FOLDER / \
     'dispatcher_functions' / \
     'dispatcher_functions_stein'
-FUNCTION_APP_DIRECTORY =  UNIT_TESTS_ROOT / 'dispatcher_functions' / \
-        'dispatcher_functions_stein'
+FUNCTION_APP_DIRECTORY = UNIT_TESTS_ROOT / 'dispatcher_functions' / \
+    'dispatcher_functions_stein'
 
 
 class TestThreadPoolSettingsPython37(testutils.AsyncTestCase):
@@ -680,10 +680,10 @@ async def test_dispatcher_load_azfunc_in_init(self):
             )
         self.assertIn("azure.functions", sys.modules)
 
-    async def test_dispatcher_indexing_in_init(self):
+    async def test_dispatcher_indexing_in_init_request(self):
         """Test if azure functions is loaded during init
         """
-        env = {"INIT_INDEXING": "1"}
+        env = {ENABLE_INIT_INDEXING: "1"}
         with patch.dict(os.environ, env):
             async with self._ctrl as host:
                 r = await host.init_worker()
@@ -696,7 +696,8 @@ async def test_dispatcher_indexing_in_init(self):
 
                 self.assertEqual(
                     len([log for log in r.logs if log.message.startswith(
-                        "Received WorkerMetadataRequest from _handle__worker_init_request"
+                        "Received WorkerMetadataRequest from "
+                        "_handle__worker_init_request"
                     )]),
                     1
                 )
@@ -752,46 +753,177 @@ async def test_dispatcher_load_modules_con_app_placeholder_disabled(self):
                 " Placeholder: False", logs)
 
 
-class DispatcherTests(unittest.TestCase):
+class TestDispatcherIndexinginInit(unittest.TestCase):
 
     def setUp(self):
         self.loop = asyncio.new_event_loop()
         asyncio.set_event_loop(self.loop)
         self.dispatcher = testutils.create_dummy_dispatcher()
+        sys.path.append(str(FUNCTION_APP_DIRECTORY))
 
     def tearDown(self):
         self.loop.close()
 
-    @patch.dict(os.environ, {'INIT_INDEXING': 'true'})
-    # @patch('azure_functions_worker.dispatcher.Dispatcher.get_function_metadata')
+    @patch.dict(os.environ, {ENABLE_INIT_INDEXING: 'true'})
     def test_worker_init_request_with_indexing_enabled(self):
-        # Set up any additional mocks needed for your test
-        # mock_get_function_metadata.return_value = None
-        import azure.functions
 
         request = protos.StreamingMessage(
-                worker_init_request=protos.WorkerInitRequest(
-                    host_version="2.3.4",
-                    function_app_directory=str(FUNCTION_APP_DIRECTORY)
-                )
+            worker_init_request=protos.WorkerInitRequest(
+                host_version="2.3.4",
+                function_app_directory=str(FUNCTION_APP_DIRECTORY)
             )
+        )
 
-        # Execute the method under test
-        result = self.loop.run_until_complete(
+        self.loop.run_until_complete(
             self.dispatcher._handle__worker_init_request(request))
 
-        # Assert conditions based on INIT_INDEXING being true
         self.assertIsNotNone(self.dispatcher.function_metadata_result)
+        self.assertIsNone(self.dispatcher.function_metadata_exception)
+
+    @patch.dict(os.environ, {ENABLE_INIT_INDEXING: 'false'})
+    def test_worker_init_request_with_indexing_disabled(self):
+        request = protos.StreamingMessage(
+            worker_init_request=protos.WorkerInitRequest(
+                host_version="2.3.4",
+                function_app_directory=str(FUNCTION_APP_DIRECTORY)
+            )
+        )
+
+        self.loop.run_until_complete(
+            self.dispatcher._handle__worker_init_request(request))
+
+        self.assertIsNone(self.dispatcher.function_metadata_result)
+        self.assertIsNone(self.dispatcher.function_metadata_exception)
+
+    @patch.dict(os.environ, {ENABLE_INIT_INDEXING: 'true'})
+    def test_worker_init_request_with_indexing_exception(self):
+        sys.path.remove(str(FUNCTION_APP_DIRECTORY))
+
+        request = protos.StreamingMessage(
+            worker_init_request=protos.WorkerInitRequest(
+                host_version="2.3.4",
+                function_app_directory=str(FUNCTION_APP_DIRECTORY)
+            )
+        )
+
+        self.loop.run_until_complete(
+            self.dispatcher._handle__worker_init_request(request))
+
+        self.assertIsNone(self.dispatcher.function_metadata_result)
+        self.assertIsNotNone(self.dispatcher.function_metadata_exception)
+
+    @patch.dict(os.environ, {ENABLE_INIT_INDEXING: 'true'})
+    def test_functions_metadata_request_with_init_indexing_enabled(self):
+        init_request = protos.StreamingMessage(
+            worker_init_request=protos.WorkerInitRequest(
+                host_version="2.3.4",
+                function_app_directory=str(FUNCTION_APP_DIRECTORY)
+            )
+        )
+
+        metadata_request = protos.StreamingMessage(
+            functions_metadata_request=protos.FunctionsMetadataRequest(
+                function_app_directory=str(FUNCTION_APP_DIRECTORY)
+            )
+        )
+
+        init_response = self.loop.run_until_complete(
+            self.dispatcher._handle__worker_init_request(init_request))
+        self.assertEqual(init_response.worker_init_response.result.status,
+                         protos.StatusResult.Success)
+
+        metadata_response = self.loop.run_until_complete(
+            self.dispatcher._handle__functions_metadata_request(metadata_request))
+
+        self.assertEqual(metadata_response.function_metadata_response.result.status,
+                         protos.StatusResult.Success)
+        self.assertIsNotNone(self.dispatcher.function_metadata_result)
+        self.assertIsNone(self.dispatcher.function_metadata_exception)
+
+    @patch.dict(os.environ, {ENABLE_INIT_INDEXING: 'false'})
+    def test_functions_metadata_request_with_init_indexing_enabled(self):
+        init_request = protos.StreamingMessage(
+            worker_init_request=protos.WorkerInitRequest(
+                host_version="2.3.4",
+                function_app_directory=str(FUNCTION_APP_DIRECTORY)
+            )
+        )
+
+        metadata_request = protos.StreamingMessage(
+            functions_metadata_request=protos.FunctionsMetadataRequest(
+                function_app_directory=str(str(FUNCTION_APP_DIRECTORY))
+            )
+        )
+
+        init_response = self.loop.run_until_complete(
+            self.dispatcher._handle__worker_init_request(init_request))
+        self.assertEqual(init_response.worker_init_response.result.status,
+                         protos.StatusResult.Success)
+        self.assertIsNone(self.dispatcher.function_metadata_result)
+        self.assertIsNone(self.dispatcher.function_metadata_exception)
+
+
+        metadata_response = self.loop.run_until_complete(
+            self.dispatcher._handle__functions_metadata_request(metadata_request))
+
+        self.assertEqual(metadata_response.function_metadata_response.result.status,
+                         protos.StatusResult.Success)
+        self.assertIsNotNone(self.dispatcher.function_metadata_result)
+        self.assertIsNone(self.dispatcher.function_metadata_exception)
 
-    @patch.dict(os.environ, {'INIT_INDEXING': 'false'})
-    @patch('yourmodule.dispatcher.Dispatcher.get_function_metadata')
-    def test_worker_init_request_with_indexing_disabled(self, mock_get_function_metadata):
-        # Execute the method under test
-        # result = self.loop.run_until_complete(self.dispatcher._handle__worker_init_request(request))
+    @patch.dict(os.environ, {ENABLE_INIT_INDEXING: 'true'})
+    def test_functions_metadata_request_with_indexing_exception(self):
+        sys.path.remove(str(FUNCTION_APP_DIRECTORY))
 
-        # Assert conditions based on INIT_INDEXING being false
-        # For example, you might expect function_metadata_result or function_metadata_exception to be set differently
-        # Adjust your assertions accordingly
-        pass
+        request = protos.StreamingMessage(
+            worker_init_request=protos.WorkerInitRequest(
+                host_version="2.3.4",
+                function_app_directory=str(FUNCTION_APP_DIRECTORY)
+            )
+        )
 
+        metadata_request = protos.StreamingMessage(
+            functions_metadata_request=protos.FunctionsMetadataRequest(
+                function_app_directory=str(FUNCTION_APP_DIRECTORY)
+            )
+        )
 
+        self.loop.run_until_complete(
+            self.dispatcher._handle__worker_init_request(request))
+
+        self.assertIsNone(self.dispatcher.function_metadata_result)
+        self.assertIsNotNone(self.dispatcher.function_metadata_exception)
+
+        metadata_response = self.loop.run_until_complete(
+            self.dispatcher._handle__functions_metadata_request(metadata_request))
+
+        self.assertEqual(metadata_response.function_metadata_response.result.status,
+                         protos.StatusResult.Failure)
+
+    @patch.dict(os.environ, {ENABLE_INIT_INDEXING: 'false'})
+    def test_dispatcher_indexing_in_load_request(self):
+        init_request = protos.StreamingMessage(
+            worker_init_request=protos.WorkerInitRequest(
+                host_version="2.3.4",
+                function_app_directory=str(FUNCTION_APP_DIRECTORY)
+            )
+        )
+
+        self.loop.run_until_complete(
+            self.dispatcher._handle__worker_init_request(init_request))
+
+        self.assertIsNone(self.dispatcher.function_metadata_result)
+
+        load_request = protos.StreamingMessage(
+                function_load_request=protos.FunctionLoadRequest(
+                    function_id="http_trigger",
+                    metadata=protos.RpcFunctionMetadata(
+                        directory=str(FUNCTION_APP_DIRECTORY),
+                        properties={"worker_indexed": "True"}
+                    )))
+
+        self.loop.run_until_complete(
+            self.dispatcher._handle__function_load_request(load_request))
+
+        self.assertIsNotNone(self.dispatcher.function_metadata_result)
+        self.assertIsNone(self.dispatcher.function_metadata_exception)