refactor(api/core/workflow/nodes/http_request): Remove `mask_authorization_header` because its alwary true. (#6379)

api/core/workflow/nodes/http_request/entities.py

     params: str
     body: Optional[HttpRequestNodeBody] = None
     timeout: Optional[HttpRequestNodeTimeout] = None
-    mask_authorization_header: Optional[bool] = True

api/core/workflow/nodes/http_request/http_executor.py

         # validate response
         return self._validate_and_parse_response(response)
 
-    def to_raw_request(self, mask_authorization_header: Optional[bool] = True) -> str:
+    def to_raw_request(self) -> str:
         """
         convert to raw request
         """
 
         headers = self._assembling_headers()
         for k, v in headers.items():
-            if mask_authorization_header:
-                # get authorization header
-                if self.authorization.type == 'api-key':
-                    authorization_header = 'Authorization'
-                    if self.authorization.config and self.authorization.config.header:
-                        authorization_header = self.authorization.config.header
-
-                    if k.lower() == authorization_header.lower():
-                        raw_request += f'{k}: {"*" * len(v)}\n'
-                        continue
+            # get authorization header
+            if self.authorization.type == 'api-key':
+                authorization_header = 'Authorization'
+                if self.authorization.config and self.authorization.config.header:
+                    authorization_header = self.authorization.config.header
+
+                if k.lower() == authorization_header.lower():
+                    raw_request += f'{k}: {"*" * len(v)}\n'
+                    continue
 
             raw_request += f'{k}: {v}\n'
 

api/core/workflow/nodes/http_request/http_request_node.py

             process_data = {}
             if http_executor:
                 process_data = {
-                    'request': http_executor.to_raw_request(
-                        mask_authorization_header=node_data.mask_authorization_header
-                    ),
+                    'request': http_executor.to_raw_request(),
                 }
             return NodeRunResult(
                 status=WorkflowNodeExecutionStatus.FAILED,
                 'files': files,
             },
             process_data={
-                'request': http_executor.to_raw_request(
-                    mask_authorization_header=node_data.mask_authorization_header,
-                ),
+                'request': http_executor.to_raw_request(),
             },
         )
 

api/core/workflow/utils/variable_template_parser.py

 import re
+from collections.abc import Mapping
+from typing import Any
 
 from core.workflow.entities.variable_entities import VariableSelector
 
 
         return variable_selectors
 
-    def format(self, inputs: dict, remove_template_variables: bool = True) -> str:
+    def format(self, inputs: Mapping[str, Any], remove_template_variables: bool = True) -> str:
         """
         Formats the template string by replacing the template variables with their corresponding values.
 
         def replacer(match):
             key = match.group(1)
             value = inputs.get(key, match.group(0))  # return original matched string if key not found
+
+            if value is None:
+                value = ''
             # convert the value to string
             if isinstance(value, list | dict | bool | int | float):
                 value = str(value)

api/tests/integration_tests/workflow/nodes/test_http.py

             'headers': 'X-Header:123',
             'params': 'A:b',
             'body': None,
-            'mask_authorization_header': False,
         }
     }, **BASIC_NODE_DATA)
 
     data = result.process_data.get('request', '')
 
     assert '?A=b' in data
-    assert 'api-key: Basic ak-xxx' in data
     assert 'X-Header: 123' in data
 
 
             'headers': 'X-Header:123',
             'params': 'A:b',
             'body': None,
-            'mask_authorization_header': False,
         }
     }, **BASIC_NODE_DATA)
 
 
     assert '?A=b' in data
     assert 'X-Header: 123' in data
-    assert 'X-Auth: Auth' in data
 
 
 @pytest.mark.parametrize('setup_http_mock', [['none']], indirect=True)
             'headers': 'X-Header:123\nX-Header2:{{#a.b123.args2#}}',
             'params': 'A:b\nTemplate:{{#a.b123.args2#}}',
             'body': None,
-            'mask_authorization_header': False,
         }
     }, **BASIC_NODE_DATA)
 
 
     assert '?A=b' in data
     assert 'Template=2' in data
-    assert 'api-key: Basic ak-xxx' in data
     assert 'X-Header: 123' in data
     assert 'X-Header2: 2' in data
 
                 'type': 'json',
                 'data': '{"a": "{{#a.b123.args1#}}"}'
             },
-            'mask_authorization_header': False,
         }
     }, **BASIC_NODE_DATA)
 
     data = result.process_data.get('request', '')
 
     assert '{"a": "1"}' in data
-    assert 'api-key: Basic ak-xxx' in data
     assert 'X-Header: 123' in data
 
 
                 'type': 'x-www-form-urlencoded',
                 'data': 'a:{{#a.b123.args1#}}\nb:{{#a.b123.args2#}}'
             },
-            'mask_authorization_header': False,
         }
     }, **BASIC_NODE_DATA)
 
     data = result.process_data.get('request', '')
 
     assert 'a=1&b=2' in data
-    assert 'api-key: Basic ak-xxx' in data
     assert 'X-Header: 123' in data
 
 
                 'type': 'form-data',
                 'data': 'a:{{#a.b123.args1#}}\nb:{{#a.b123.args2#}}'
             },
-            'mask_authorization_header': False,
         }
     }, **BASIC_NODE_DATA)
 
     assert '1' in data
     assert 'form-data; name="b"' in data
     assert '2' in data
-    assert 'api-key: Basic ak-xxx' in data
     assert 'X-Header: 123' in data
 
 
                 'type': 'none',
                 'data': '123123123'
             },
-            'mask_authorization_header': False,
         }
     }, **BASIC_NODE_DATA)
 
     result = node.run(pool)
     data = result.process_data.get('request', '')
 
-    assert 'api-key: Basic ak-xxx' in data
     assert 'X-Header: 123' in data
     assert '123123123' not in data
 
             'body': None,
             'params': '',
             'headers': 'X-Header:123',
-            'mask_authorization_header': False,
         }
     }, **BASIC_NODE_DATA)
 
                 'type': 'form-data',
                 'data': 'Referer:http://example5.com\nRedirect:http://example6.com'
             },
-            'mask_authorization_header': False,
         }
     }, **BASIC_NODE_DATA)