feat: Adding deferred bindings logs (#28)

* adding log array to dict repr

* fixed tests

* nested dict, different name

* fixed tests

---------

Co-authored-by: Victoria Hall <[email protected]>

Author: hallvictoria

azure-functions-extension-base/azure/functions/extension/base/meta.py

@@ -83,7 +83,7 @@ def get(cls, binding_name):
         return cls._bindings.get(binding_name)
 
     @classmethod
-    def get_raw_bindings(cls, indexed_function, input_types) -> List[str]:
+    def get_raw_bindings(cls, indexed_function, input_types):
         return utils.get_raw_bindings(indexed_function, input_types)
 
     @classmethod

azure-functions-extension-base/azure/functions/extension/base/utils.py

@@ -160,37 +160,44 @@ def data_type(self) -> Optional[int]:
     def direction(self) -> int:
         return self._direction.value
 
-    def get_dict_repr(binding, input_types) -> Dict:
+    def get_dict_repr(binding, input_types):
         """Build a dictionary of a particular binding. The keys are camel
         cased binding field names defined in `init_params` list and
         :class:`Binding` class. \n
         This method is invoked in function :meth:`get_raw_bindings` of class
         :class:`Function` to generate json dict for each binding.
 
-        :return: Dictionary representation of the binding.
+        :return: Dictionary representation of the binding. Tuple representation
+        of the binding in the format:
+        ((binding type, pytype), deferred bindings enabled)
         """
         params = list(dict.fromkeys(getattr(binding, "init_params", [])))
+        binding_info = {}
         for p in params:
             if p not in Binding.EXCLUDED_INIT_PARAMS:
                 binding._dict[to_camel_case(p)] = getattr(binding, p, None)
 
+        if input_types.get(binding.name) is not None:
+            pytype = input_types.get(binding.name).pytype
+        else:
+            pytype = None
         # Adding flag to signal to the host to send MBD object
         # 1. check if the binding is a supported type (blob, blobTrigger)
         # 2. check if the binding is an input binding
         # 3. check if the defined type is an SdkType
         if (
             binding.type in meta._ConverterMeta._bindings
             and binding.direction == 0
-            and meta._ConverterMeta.check_supported_type(
-                input_types.get(binding.name).pytype
-            )
+            and meta._ConverterMeta.check_supported_type(pytype)
         ):
             binding._dict["properties"] = {"SupportsDeferredBinding": True}
+            binding_info = {binding.name: {pytype: "True"}}
         # if it isn't, we set the flag to false
         else:
             binding._dict["properties"] = {"SupportsDeferredBinding": False}
+            binding_info = {binding.name: {pytype: "False"}}
 
-        return binding._dict
+        return binding._dict, binding_info
 
 
 def to_camel_case(snake_case_str: str):
@@ -238,8 +245,11 @@ def is_word(input_string: str) -> bool:
     return WORD_RE.match(input_string) is not None
 
 
-def get_raw_bindings(indexed_function, input_types) -> List[str]:
-    return [
-        json.dumps(Binding.get_dict_repr(b, input_types), cls=StringifyEnumJsonEncoder)
-        for b in indexed_function._bindings
-    ]
+def get_raw_bindings(indexed_function, input_types):
+    binding_dict_repr = []
+    bindings_logs = {}
+    for b in indexed_function._bindings:
+        dict_repr, logs = Binding.get_dict_repr(b, input_types)
+        binding_dict_repr.append(json.dumps(dict_repr, cls=StringifyEnumJsonEncoder))
+        bindings_logs.update(logs)
+    return binding_dict_repr, bindings_logs

azure-functions-extension-base/tests/test_meta.py

@@ -146,7 +146,7 @@ class MockIndexedFunction:
             _bindings = {}
             _trigger = None
 
-        self.assertEqual(registry.get_raw_bindings(MockIndexedFunction, []), [])
+        self.assertEqual(registry.get_raw_bindings(MockIndexedFunction, []), ([], {}))
 
         self.assertFalse(registry.check_supported_type(None))
         self.assertFalse(registry.check_supported_type("hello"))

azure-functions-extension-base/tests/test_utils.py

@@ -56,7 +56,9 @@ def test_get_dict_repr_sdk(self):
         # Create test indexed_function
         mock_indexed_functions = MockFunction(bindings=[mock_blob])
 
-        dict_repr = utils.get_raw_bindings(mock_indexed_functions, mock_input_types)
+        dict_repr, logs = utils.get_raw_bindings(
+            mock_indexed_functions, mock_input_types
+        )
         self.assertEqual(
             dict_repr,
             [
@@ -67,6 +69,8 @@ def test_get_dict_repr_sdk(self):
             ],
         )
 
+        self.assertEqual(logs, {"client": {sdkType.SdkType: "True"}})
+
     def test_get_dict_repr_non_sdk(self):
         # Create mock blob
         meta._ConverterMeta._bindings = {"blob"}
@@ -87,7 +91,9 @@ def test_get_dict_repr_non_sdk(self):
         # Create test indexed_function
         mock_indexed_functions = MockFunction(bindings=[mock_blob])
 
-        dict_repr = utils.get_raw_bindings(mock_indexed_functions, mock_input_types)
+        dict_repr, logs = utils.get_raw_bindings(
+            mock_indexed_functions, mock_input_types
+        )
         self.assertEqual(
             dict_repr,
             [
@@ -97,6 +103,48 @@ def test_get_dict_repr_non_sdk(self):
                 '{"SupportsDeferredBinding": false}}'
             ],
         )
+        self.assertEqual(logs, {"blob": {bytes: "False"}})
+
+    def test_get_dict_repr_binding_name_none(self):
+        # Create mock blob
+        meta._ConverterMeta._bindings = {"blob"}
+
+        # Create test binding
+        mock_blob = utils.Binding(
+            name="blob",
+            direction=utils.BindingDirection.IN,
+            data_type=None,
+            type="blob",
+        )
+
+        mock_http = utils.Binding(
+            name="$return",
+            direction=utils.BindingDirection.OUT,
+            data_type=None,
+            type="httpResponse",
+        )
+
+        # Create test input_types dict
+        mock_input_types = {
+            "blob": MockParamTypeInfo(binding_name="blobTrigger", pytype=bytes)
+        }
+
+        # Create test indexed_function
+        mock_indexed_functions = MockFunction(bindings=[mock_blob, mock_http])
+
+        dict_repr, logs = utils.get_raw_bindings(
+            mock_indexed_functions, mock_input_types
+        )
+        self.assertEqual(
+            dict_repr,
+            [
+                '{"direction": "IN", "dataType": null, "type": "blob", '
+                '"properties": {"SupportsDeferredBinding": false}}',
+                '{"direction": "OUT", "dataType": null, "type": "httpResponse", '
+                '"properties": {"SupportsDeferredBinding": false}}',
+            ],
+        )
+        self.assertEqual(logs, {"$return": {None: "False"}, "blob": {bytes: "False"}})
 
     def test_get_dict_repr_init_params(self):
         # Create mock blob
@@ -121,7 +169,9 @@ def test_get_dict_repr_init_params(self):
         # Create test indexed_function
         mock_indexed_functions = MockFunction(bindings=[mock_blob])
 
-        dict_repr = utils.get_raw_bindings(mock_indexed_functions, mock_input_types)
+        dict_repr, logs = utils.get_raw_bindings(
+            mock_indexed_functions, mock_input_types
+        )
         self.assertEqual(
             dict_repr,
             [
@@ -131,6 +181,8 @@ def test_get_dict_repr_init_params(self):
             ],
         )
 
+        self.assertEqual(logs, {"client": {sdkType.SdkType: "True"}})
+
     def test_binding_data_type(self):
         mock_blob = utils.Binding(
             name="blob",