log warning for function app without http functions (#138)

* log warning for function app without http functions

* add tests

* fix flakey

* addr comment

Co-authored-by: peterstone2017 <[email protected]>

Author: YunchuWang

azure/functions/decorators/function_app.py

@@ -1,6 +1,7 @@
 #  Copyright (c) Microsoft Corporation. All rights reserved.
 #  Licensed under the MIT License.
 import json
+import logging
 from abc import ABC
 from typing import Callable, Dict, List, Optional, Union, Iterable
 
@@ -46,6 +47,7 @@ def __init__(self, func: Callable, script_file: str):
         self._bindings: List[Binding] = []
         self.function_script_file = script_file
         self.http_type = 'function'
+        self._is_http_function = False
 
     def add_binding(self, binding: Binding) -> None:
         """Add a binding instance to the function.
@@ -72,7 +74,6 @@ def add_trigger(self, trigger: Trigger) -> None:
                              f"being added is {trigger.get_dict_repr()}")
 
         self._trigger = trigger
-
         #  We still add the trigger info to the bindings to ensure that
         #  function.json is complete
         self._bindings.append(trigger)
@@ -93,6 +94,9 @@ def set_http_type(self, http_type: str) -> None:
         """
         self.http_type = http_type
 
+    def is_http_function(self) -> bool:
+        return self._is_http_function
+
     def get_trigger(self) -> Optional[Trigger]:
         """Get attached trigger instance of the function.
 
@@ -212,6 +216,7 @@ def _validate_function(self,
                 getattr(trigger, 'init_params').add('auth_level')
                 setattr(trigger, 'auth_level',
                         parse_singular_param_to_enum(auth_level, AuthLevel))
+            self._function._is_http_function = True
 
     def build(self, auth_level: Optional[AuthLevel] = None) -> Function:
         """
@@ -1614,14 +1619,29 @@ def __init__(self, auth_level: Union[AuthLevel, str], *args, **kwargs):
         """
         DecoratorApi.__init__(self, *args, **kwargs)
         HttpFunctionsAuthLevelMixin.__init__(self, auth_level, *args, **kwargs)
+        self._require_auth_level: Optional[bool] = None
 
     def get_functions(self) -> List[Function]:
         """Get the function objects in the function app.
 
         :return: List of functions in the function app.
         """
-        return [function_builder.build(self.auth_level) for function_builder
-                in self._function_builders]
+        functions = [function_builder.build(self.auth_level)
+                     for function_builder in self._function_builders]
+
+        if not self._require_auth_level:
+            self._require_auth_level = any(
+                function.is_http_function() for function in functions)
+
+        if not self._require_auth_level:
+            logging.warning(
+                'Auth level is not applied to non http '
+                'function app. Ref: '
+                'https://docs.microsoft.com/azure/azure-functions/functions'
+                '-bindings-http-webhook-trigger?tabs=in-process'
+                '%2Cfunctionsv2&pivots=programming-language-python#http-auth')
+
+        return functions
 
     def register_functions(self, function_container: DecoratorApi) -> None:
         """Register a list of functions in the function app.

tests/decorators/test_decorators.py

@@ -867,6 +867,21 @@ def dummy():
             "connectionStringSetting": "dummy_str"
         })
 
+    def test_not_http_function(self):
+        app = self.func_app
+
+        @app.cosmos_db_trigger(arg_name="trigger",
+                               database_name="dummy_db",
+                               collection_name="dummy_collection",
+                               connection_string_setting="dummy_str")
+        def dummy():
+            pass
+
+        funcs = app.get_functions()
+        self.assertEqual(len(funcs), 1)
+
+        self.assertFalse(funcs[0].is_http_function())
+
     def test_cosmosdb_input_binding(self):
         app = self.func_app
 
@@ -1060,6 +1075,8 @@ def default_auth_level():
         http_func_1 = funcs[0]
         http_func_2 = funcs[1]
 
+        self.assertTrue(http_func_1.is_http_function())
+        self.assertTrue(http_func_2.is_http_function())
         self.assertEqual(http_func_1.get_user_function().__name__,
                          "specify_auth_level")
         self.assertEqual(http_func_2.get_user_function().__name__,
@@ -1351,6 +1368,8 @@ def dummy():
         func = self._get_user_function(app)
 
         self.assertEqual(len(func.get_bindings()), 1)
+        self.assertTrue(func.is_http_function())
+
         output = func.get_bindings()[0]
 
         self.assertEqual(output.get_dict_repr(), {

tests/decorators/test_function_app.py

@@ -11,7 +11,7 @@
     BindingDirection, SCRIPT_FILE_NAME
 from azure.functions.decorators.function_app import FunctionBuilder, \
     FunctionApp, Function, Blueprint, DecoratorApi, AsgiFunctionApp, \
-    WsgiFunctionApp, HttpFunctionsAuthLevelMixin, FunctionRegister
+    WsgiFunctionApp, HttpFunctionsAuthLevelMixin, FunctionRegister, TriggerApi
 from azure.functions.decorators.http import HttpTrigger, HttpOutput, \
     HttpMethod
 from tests.decorators.test_core import DummyTrigger
@@ -459,9 +459,48 @@ class DummyFunctionApp(FunctionRegister):
         self.assertIsNotNone(getattr(app, "function_name", None))
         self.assertIsNotNone(getattr(app, "_validate_type", None))
         self.assertIsNotNone(getattr(app, "_configure_function_builder", None))
+        self.assertIsNone(getattr(app, "_require_auth_level"))
         self.assertTrue(hasattr(app, "auth_level"))
         self.assertEqual(app.auth_level, AuthLevel.ANONYMOUS)
 
+    def test_function_register_http_function_app(self):
+        class DummyFunctionApp(FunctionRegister, TriggerApi):
+            pass
+
+        app = DummyFunctionApp(auth_level=AuthLevel.ANONYMOUS)
+
+        @app.route("name1")
+        def hello1(name: str):
+            return "hello"
+
+        @app.schedule(arg_name="name", schedule="10****")
+        def hello2(name: str):
+            return "hello"
+
+        @app.route("name1")
+        def hello3(name: str):
+            return "hello"
+
+        self.assertIsNone(app._require_auth_level, None)
+        app.get_functions()
+        self.assertTrue(app._require_auth_level)
+
+    def test_function_register_non_http_function_app(self):
+        class DummyFunctionApp(FunctionRegister, TriggerApi):
+            pass
+
+        app = DummyFunctionApp(auth_level=AuthLevel.ANONYMOUS)
+        blueprint = Blueprint()
+
+        @blueprint.schedule(arg_name="name", schedule="10****")
+        def hello(name: str):
+            return name
+
+        app.register_blueprint(blueprint)
+
+        app.get_functions()
+        self.assertFalse(app._require_auth_level)
+
     def test_function_register_register_function_register_error(self):
         class DummyFunctionApp(FunctionRegister):
             pass
@@ -506,6 +545,13 @@ def test_asgi_function_app_custom(self):
                               http_auth_level=AuthLevel.ANONYMOUS)
         self.assertEqual(app.auth_level, AuthLevel.ANONYMOUS)
 
+    def test_asgi_function_app_is_http_function(self):
+        app = AsgiFunctionApp(app=object())
+        funcs = app.get_functions()
+
+        self.assertEqual(len(funcs), 1)
+        self.assertTrue(funcs[0].is_http_function())
+
     def test_wsgi_function_app_default(self):
         app = WsgiFunctionApp(app=object())
         self.assertEqual(app.auth_level, AuthLevel.FUNCTION)
@@ -514,3 +560,10 @@ def test_wsgi_function_app_custom(self):
         app = WsgiFunctionApp(app=object(),
                               http_auth_level=AuthLevel.ANONYMOUS)
         self.assertEqual(app.auth_level, AuthLevel.ANONYMOUS)
+
+    def test_wsgi_function_app_is_http_function(self):
+        app = WsgiFunctionApp(app=object())
+        funcs = app.get_functions()
+
+        self.assertEqual(len(funcs), 1)
+        self.assertTrue(funcs[0].is_http_function())