FEAT: NEW WORKFLOW ENGINE (#3160)

Co-authored-by: Joel <iamjoel007@gmail.com>
Co-authored-by: Yeuoly <admin@srmxy.cn>
Co-authored-by: JzoNg <jzongcode@gmail.com>
Co-authored-by: StyleZhang <jasonapring2015@outlook.com>
Co-authored-by: jyong <jyong@dify.ai>
Co-authored-by: nite-knite <nkCoding@gmail.com>
Co-authored-by: jyong <718720800@qq.com>

api/tests/unit_tests/core/prompt/test_advanced_prompt_transform.py

@@ -0,0 +1,211 @@
+from unittest.mock import MagicMock
+
+import pytest
+
+from core.app.app_config.entities import ModelConfigEntity, FileExtraConfig
+from core.file.file_obj import FileVar, FileType, FileTransferMethod
+from core.memory.token_buffer_memory import TokenBufferMemory
+from core.model_runtime.entities.message_entities import UserPromptMessage, AssistantPromptMessage, PromptMessageRole
+from core.prompt.advanced_prompt_transform import AdvancedPromptTransform
+from core.prompt.entities.advanced_prompt_entities import CompletionModelPromptTemplate, MemoryConfig, ChatModelMessage
+from core.prompt.utils.prompt_template_parser import PromptTemplateParser
+from models.model import Conversation
+
+
+def test__get_completion_model_prompt_messages():
+    model_config_mock = MagicMock(spec=ModelConfigEntity)
+    model_config_mock.provider = 'openai'
+    model_config_mock.model = 'gpt-3.5-turbo-instruct'
+
+    prompt_template = "Context:\n{{#context#}}\n\nHistories:\n{{#histories#}}\n\nyou are {{name}}."
+    prompt_template_config = CompletionModelPromptTemplate(
+        text=prompt_template
+    )
+
+    memory_config = MemoryConfig(
+        role_prefix=MemoryConfig.RolePrefix(
+            user="Human",
+            assistant="Assistant"
+        ),
+        window=MemoryConfig.WindowConfig(
+            enabled=False
+        )
+    )
+
+    inputs = {
+        "name": "John"
+    }
+    files = []
+    context = "I am superman."
+
+    memory = TokenBufferMemory(
+        conversation=Conversation(),
+        model_instance=model_config_mock
+    )
+
+    history_prompt_messages = [
+        UserPromptMessage(content="Hi"),
+        AssistantPromptMessage(content="Hello")
+    ]
+    memory.get_history_prompt_messages = MagicMock(return_value=history_prompt_messages)
+
+    prompt_transform = AdvancedPromptTransform()
+    prompt_transform._calculate_rest_token = MagicMock(return_value=2000)
+    prompt_messages = prompt_transform._get_completion_model_prompt_messages(
+        prompt_template=prompt_template_config,
+        inputs=inputs,
+        query=None,
+        files=files,
+        context=context,
+        memory_config=memory_config,
+        memory=memory,
+        model_config=model_config_mock
+    )
+
+    assert len(prompt_messages) == 1
+    assert prompt_messages[0].content == PromptTemplateParser(template=prompt_template).format({
+        "#context#": context,
+        "#histories#": "\n".join([f"{'Human' if prompt.role.value == 'user' else 'Assistant'}: "
+                                  f"{prompt.content}" for prompt in history_prompt_messages]),
+        **inputs,
+    })
+
+
+def test__get_chat_model_prompt_messages(get_chat_model_args):
+    model_config_mock, memory_config, messages, inputs, context = get_chat_model_args
+
+    files = []
+    query = "Hi2."
+
+    memory = TokenBufferMemory(
+        conversation=Conversation(),
+        model_instance=model_config_mock
+    )
+
+    history_prompt_messages = [
+        UserPromptMessage(content="Hi1."),
+        AssistantPromptMessage(content="Hello1!")
+    ]
+    memory.get_history_prompt_messages = MagicMock(return_value=history_prompt_messages)
+
+    prompt_transform = AdvancedPromptTransform()
+    prompt_transform._calculate_rest_token = MagicMock(return_value=2000)
+    prompt_messages = prompt_transform._get_chat_model_prompt_messages(
+        prompt_template=messages,
+        inputs=inputs,
+        query=query,
+        files=files,
+        context=context,
+        memory_config=memory_config,
+        memory=memory,
+        model_config=model_config_mock
+    )
+
+    assert len(prompt_messages) == 6
+    assert prompt_messages[0].role == PromptMessageRole.SYSTEM
+    assert prompt_messages[0].content == PromptTemplateParser(
+        template=messages[0].text
+    ).format({**inputs, "#context#": context})
+    assert prompt_messages[5].content == query
+
+
+def test__get_chat_model_prompt_messages_no_memory(get_chat_model_args):
+    model_config_mock, _, messages, inputs, context = get_chat_model_args
+
+    files = []
+
+    prompt_transform = AdvancedPromptTransform()
+    prompt_transform._calculate_rest_token = MagicMock(return_value=2000)
+    prompt_messages = prompt_transform._get_chat_model_prompt_messages(
+        prompt_template=messages,
+        inputs=inputs,
+        query=None,
+        files=files,
+        context=context,
+        memory_config=None,
+        memory=None,
+        model_config=model_config_mock
+    )
+
+    assert len(prompt_messages) == 3
+    assert prompt_messages[0].role == PromptMessageRole.SYSTEM
+    assert prompt_messages[0].content == PromptTemplateParser(
+        template=messages[0].text
+    ).format({**inputs, "#context#": context})
+
+
+def test__get_chat_model_prompt_messages_with_files_no_memory(get_chat_model_args):
+    model_config_mock, _, messages, inputs, context = get_chat_model_args
+
+    files = [
+        FileVar(
+            id="file1",
+            tenant_id="tenant1",
+            type=FileType.IMAGE,
+            transfer_method=FileTransferMethod.REMOTE_URL,
+            url="https://example.com/image1.jpg",
+            extra_config=FileExtraConfig(
+                image_config={
+                    "detail": "high",
+                }
+            )
+        )
+    ]
+
+    prompt_transform = AdvancedPromptTransform()
+    prompt_transform._calculate_rest_token = MagicMock(return_value=2000)
+    prompt_messages = prompt_transform._get_chat_model_prompt_messages(
+        prompt_template=messages,
+        inputs=inputs,
+        query=None,
+        files=files,
+        context=context,
+        memory_config=None,
+        memory=None,
+        model_config=model_config_mock
+    )
+
+    assert len(prompt_messages) == 4
+    assert prompt_messages[0].role == PromptMessageRole.SYSTEM
+    assert prompt_messages[0].content == PromptTemplateParser(
+        template=messages[0].text
+    ).format({**inputs, "#context#": context})
+    assert isinstance(prompt_messages[3].content, list)
+    assert len(prompt_messages[3].content) == 2
+    assert prompt_messages[3].content[1].data == files[0].url
+
+
+@pytest.fixture
+def get_chat_model_args():
+    model_config_mock = MagicMock(spec=ModelConfigEntity)
+    model_config_mock.provider = 'openai'
+    model_config_mock.model = 'gpt-4'
+
+    memory_config = MemoryConfig(
+        window=MemoryConfig.WindowConfig(
+            enabled=False
+        )
+    )
+
+    prompt_messages = [
+        ChatModelMessage(
+            text="You are a helpful assistant named {{name}}.\n\nContext:\n{{#context#}}",
+            role=PromptMessageRole.SYSTEM
+        ),
+        ChatModelMessage(
+            text="Hi.",
+            role=PromptMessageRole.USER
+        ),
+        ChatModelMessage(
+            text="Hello!",
+            role=PromptMessageRole.ASSISTANT
+        )
+    ]
+
+    inputs = {
+        "name": "John"
+    }
+
+    context = "I am superman."
+
+    return model_config_mock, memory_config, prompt_messages, inputs, context

api/tests/unit_tests/core/prompt/test_prompt_transform.py

@@ -0,0 +1,47 @@
+from unittest.mock import MagicMock
+
+from core.app.app_config.entities import ModelConfigEntity
+from core.entities.provider_configuration import ProviderModelBundle
+from core.model_runtime.entities.message_entities import UserPromptMessage
+from core.model_runtime.entities.model_entities import ModelPropertyKey, AIModelEntity, ParameterRule
+from core.model_runtime.model_providers.__base.large_language_model import LargeLanguageModel
+from core.prompt.prompt_transform import PromptTransform
+
+
+def test__calculate_rest_token():
+    model_schema_mock = MagicMock(spec=AIModelEntity)
+    parameter_rule_mock = MagicMock(spec=ParameterRule)
+    parameter_rule_mock.name = 'max_tokens'
+    model_schema_mock.parameter_rules = [
+        parameter_rule_mock
+    ]
+    model_schema_mock.model_properties = {
+        ModelPropertyKey.CONTEXT_SIZE: 62
+    }
+
+    large_language_model_mock = MagicMock(spec=LargeLanguageModel)
+    large_language_model_mock.get_num_tokens.return_value = 6
+
+    provider_model_bundle_mock = MagicMock(spec=ProviderModelBundle)
+    provider_model_bundle_mock.model_type_instance = large_language_model_mock
+
+    model_config_mock = MagicMock(spec=ModelConfigEntity)
+    model_config_mock.model = 'gpt-4'
+    model_config_mock.credentials = {}
+    model_config_mock.parameters = {
+        'max_tokens': 50
+    }
+    model_config_mock.model_schema = model_schema_mock
+    model_config_mock.provider_model_bundle = provider_model_bundle_mock
+
+    prompt_transform = PromptTransform()
+
+    prompt_messages = [UserPromptMessage(content="Hello, how are you?")]
+    rest_tokens = prompt_transform._calculate_rest_token(prompt_messages, model_config_mock)
+
+    # Validate based on the mock configuration and expected logic
+    expected_rest_tokens = (model_schema_mock.model_properties[ModelPropertyKey.CONTEXT_SIZE]
+                            - model_config_mock.parameters['max_tokens']
+                            - large_language_model_mock.get_num_tokens.return_value)
+    assert rest_tokens == expected_rest_tokens
+    assert rest_tokens == 6

api/tests/unit_tests/core/prompt/test_simple_prompt_transform.py

@@ -0,0 +1,248 @@
+from unittest.mock import MagicMock
+
+from core.app.entities.app_invoke_entities import ModelConfigWithCredentialsEntity
+from core.memory.token_buffer_memory import TokenBufferMemory
+from core.model_runtime.entities.message_entities import UserPromptMessage, AssistantPromptMessage
+from core.prompt.simple_prompt_transform import SimplePromptTransform
+from models.model import AppMode, Conversation
+
+
+def test_get_common_chat_app_prompt_template_with_pcqm():
+    prompt_transform = SimplePromptTransform()
+    pre_prompt = "You are a helpful assistant."
+    prompt_template = prompt_transform.get_prompt_template(
+        app_mode=AppMode.CHAT,
+        provider="openai",
+        model="gpt-4",
+        pre_prompt=pre_prompt,
+        has_context=True,
+        query_in_prompt=True,
+        with_memory_prompt=True,
+    )
+    prompt_rules = prompt_template['prompt_rules']
+    assert prompt_template['prompt_template'].template == (prompt_rules['context_prompt']
+                                                           + pre_prompt + '\n'
+                                                           + prompt_rules['histories_prompt']
+                                                           + prompt_rules['query_prompt'])
+    assert prompt_template['special_variable_keys'] == ['#context#', '#histories#', '#query#']
+
+
+def test_get_baichuan_chat_app_prompt_template_with_pcqm():
+    prompt_transform = SimplePromptTransform()
+    pre_prompt = "You are a helpful assistant."
+    prompt_template = prompt_transform.get_prompt_template(
+        app_mode=AppMode.CHAT,
+        provider="baichuan",
+        model="Baichuan2-53B",
+        pre_prompt=pre_prompt,
+        has_context=True,
+        query_in_prompt=True,
+        with_memory_prompt=True,
+    )
+    prompt_rules = prompt_template['prompt_rules']
+    assert prompt_template['prompt_template'].template == (prompt_rules['context_prompt']
+                                                           + pre_prompt + '\n'
+                                                           + prompt_rules['histories_prompt']
+                                                           + prompt_rules['query_prompt'])
+    assert prompt_template['special_variable_keys'] == ['#context#', '#histories#', '#query#']
+
+
+def test_get_common_completion_app_prompt_template_with_pcq():
+    prompt_transform = SimplePromptTransform()
+    pre_prompt = "You are a helpful assistant."
+    prompt_template = prompt_transform.get_prompt_template(
+        app_mode=AppMode.WORKFLOW,
+        provider="openai",
+        model="gpt-4",
+        pre_prompt=pre_prompt,
+        has_context=True,
+        query_in_prompt=True,
+        with_memory_prompt=False,
+    )
+    prompt_rules = prompt_template['prompt_rules']
+    assert prompt_template['prompt_template'].template == (prompt_rules['context_prompt']
+                                                           + pre_prompt + '\n'
+                                                           + prompt_rules['query_prompt'])
+    assert prompt_template['special_variable_keys'] == ['#context#', '#query#']
+
+
+def test_get_baichuan_completion_app_prompt_template_with_pcq():
+    prompt_transform = SimplePromptTransform()
+    pre_prompt = "You are a helpful assistant."
+    prompt_template = prompt_transform.get_prompt_template(
+        app_mode=AppMode.WORKFLOW,
+        provider="baichuan",
+        model="Baichuan2-53B",
+        pre_prompt=pre_prompt,
+        has_context=True,
+        query_in_prompt=True,
+        with_memory_prompt=False,
+    )
+    print(prompt_template['prompt_template'].template)
+    prompt_rules = prompt_template['prompt_rules']
+    assert prompt_template['prompt_template'].template == (prompt_rules['context_prompt']
+                                                           + pre_prompt + '\n'
+                                                           + prompt_rules['query_prompt'])
+    assert prompt_template['special_variable_keys'] == ['#context#', '#query#']
+
+
+def test_get_common_chat_app_prompt_template_with_q():
+    prompt_transform = SimplePromptTransform()
+    pre_prompt = ""
+    prompt_template = prompt_transform.get_prompt_template(
+        app_mode=AppMode.CHAT,
+        provider="openai",
+        model="gpt-4",
+        pre_prompt=pre_prompt,
+        has_context=False,
+        query_in_prompt=True,
+        with_memory_prompt=False,
+    )
+    prompt_rules = prompt_template['prompt_rules']
+    assert prompt_template['prompt_template'].template == prompt_rules['query_prompt']
+    assert prompt_template['special_variable_keys'] == ['#query#']
+
+
+def test_get_common_chat_app_prompt_template_with_cq():
+    prompt_transform = SimplePromptTransform()
+    pre_prompt = ""
+    prompt_template = prompt_transform.get_prompt_template(
+        app_mode=AppMode.CHAT,
+        provider="openai",
+        model="gpt-4",
+        pre_prompt=pre_prompt,
+        has_context=True,
+        query_in_prompt=True,
+        with_memory_prompt=False,
+    )
+    prompt_rules = prompt_template['prompt_rules']
+    assert prompt_template['prompt_template'].template == (prompt_rules['context_prompt']
+                                                           + prompt_rules['query_prompt'])
+    assert prompt_template['special_variable_keys'] == ['#context#', '#query#']
+
+
+def test_get_common_chat_app_prompt_template_with_p():
+    prompt_transform = SimplePromptTransform()
+    pre_prompt = "you are {{name}}"
+    prompt_template = prompt_transform.get_prompt_template(
+        app_mode=AppMode.CHAT,
+        provider="openai",
+        model="gpt-4",
+        pre_prompt=pre_prompt,
+        has_context=False,
+        query_in_prompt=False,
+        with_memory_prompt=False,
+    )
+    assert prompt_template['prompt_template'].template == pre_prompt + '\n'
+    assert prompt_template['custom_variable_keys'] == ['name']
+    assert prompt_template['special_variable_keys'] == []
+
+
+def test__get_chat_model_prompt_messages():
+    model_config_mock = MagicMock(spec=ModelConfigWithCredentialsEntity)
+    model_config_mock.provider = 'openai'
+    model_config_mock.model = 'gpt-4'
+
+    memory_mock = MagicMock(spec=TokenBufferMemory)
+    history_prompt_messages = [
+        UserPromptMessage(content="Hi"),
+        AssistantPromptMessage(content="Hello")
+    ]
+    memory_mock.get_history_prompt_messages.return_value = history_prompt_messages
+
+    prompt_transform = SimplePromptTransform()
+    prompt_transform._calculate_rest_token = MagicMock(return_value=2000)
+
+    pre_prompt = "You are a helpful assistant {{name}}."
+    inputs = {
+        "name": "John"
+    }
+    context = "yes or no."
+    query = "How are you?"
+    prompt_messages, _ = prompt_transform._get_chat_model_prompt_messages(
+        app_mode=AppMode.CHAT,
+        pre_prompt=pre_prompt,
+        inputs=inputs,
+        query=query,
+        files=[],
+        context=context,
+        memory=memory_mock,
+        model_config=model_config_mock
+    )
+
+    prompt_template = prompt_transform.get_prompt_template(
+        app_mode=AppMode.CHAT,
+        provider=model_config_mock.provider,
+        model=model_config_mock.model,
+        pre_prompt=pre_prompt,
+        has_context=True,
+        query_in_prompt=False,
+        with_memory_prompt=False,
+    )
+
+    full_inputs = {**inputs, '#context#': context}
+    real_system_prompt = prompt_template['prompt_template'].format(full_inputs)
+
+    assert len(prompt_messages) == 4
+    assert prompt_messages[0].content == real_system_prompt
+    assert prompt_messages[1].content == history_prompt_messages[0].content
+    assert prompt_messages[2].content == history_prompt_messages[1].content
+    assert prompt_messages[3].content == query
+
+
+def test__get_completion_model_prompt_messages():
+    model_config_mock = MagicMock(spec=ModelConfigWithCredentialsEntity)
+    model_config_mock.provider = 'openai'
+    model_config_mock.model = 'gpt-3.5-turbo-instruct'
+
+    memory = TokenBufferMemory(
+        conversation=Conversation(),
+        model_instance=model_config_mock
+    )
+
+    history_prompt_messages = [
+        UserPromptMessage(content="Hi"),
+        AssistantPromptMessage(content="Hello")
+    ]
+    memory.get_history_prompt_messages = MagicMock(return_value=history_prompt_messages)
+
+    prompt_transform = SimplePromptTransform()
+    prompt_transform._calculate_rest_token = MagicMock(return_value=2000)
+    pre_prompt = "You are a helpful assistant {{name}}."
+    inputs = {
+        "name": "John"
+    }
+    context = "yes or no."
+    query = "How are you?"
+    prompt_messages, stops = prompt_transform._get_completion_model_prompt_messages(
+        app_mode=AppMode.CHAT,
+        pre_prompt=pre_prompt,
+        inputs=inputs,
+        query=query,
+        files=[],
+        context=context,
+        memory=memory,
+        model_config=model_config_mock
+    )
+
+    prompt_template = prompt_transform.get_prompt_template(
+        app_mode=AppMode.CHAT,
+        provider=model_config_mock.provider,
+        model=model_config_mock.model,
+        pre_prompt=pre_prompt,
+        has_context=True,
+        query_in_prompt=True,
+        with_memory_prompt=True,
+    )
+
+    prompt_rules = prompt_template['prompt_rules']
+    full_inputs = {**inputs, '#context#': context, '#query#': query, '#histories#': memory.get_history_prompt_text(
+        max_token_limit=2000,
+        ai_prefix=prompt_rules['human_prefix'] if 'human_prefix' in prompt_rules else 'Human',
+        human_prefix=prompt_rules['assistant_prefix'] if 'assistant_prefix' in prompt_rules else 'Assistant'
+    )}
+    real_prompt = prompt_template['prompt_template'].format(full_inputs)
+
+    assert len(prompt_messages) == 1
+    assert stops == prompt_rules.get('stops')
+    assert prompt_messages[0].content == real_prompt

api/tests/unit_tests/core/workflow/nodes/test_answer.py

@@ -0,0 +1,42 @@
+from unittest.mock import MagicMock
+
+from core.workflow.entities.node_entities import SystemVariable
+from core.workflow.entities.variable_pool import VariablePool
+from core.workflow.nodes.answer.answer_node import AnswerNode
+from core.workflow.nodes.base_node import UserFrom
+from extensions.ext_database import db
+from models.workflow import WorkflowNodeExecutionStatus
+
+
+def test_execute_answer():
+    node = AnswerNode(
+        tenant_id='1',
+        app_id='1',
+        workflow_id='1',
+        user_id='1',
+        user_from=UserFrom.ACCOUNT,
+        config={
+            'id': 'answer',
+            'data': {
+                'title': '123',
+                'type': 'answer',
+                'answer': 'Today\'s weather is {{#start.weather#}}\n{{#llm.text#}}\n{{img}}\nFin.'
+            }
+        }
+    )
+
+    # construct variable pool
+    pool = VariablePool(system_variables={
+        SystemVariable.FILES: [],
+    }, user_inputs={})
+    pool.append_variable(node_id='start', variable_key_list=['weather'], value='sunny')
+    pool.append_variable(node_id='llm', variable_key_list=['text'], value='You are a helpful AI.')
+
+    # Mock db.session.close()
+    db.session.close = MagicMock()
+
+    # execute node
+    result = node._run(pool)
+
+    assert result.status == WorkflowNodeExecutionStatus.SUCCEEDED
+    assert result.outputs['answer'] == "Today's weather is sunny\nYou are a helpful AI.\n{{img}}\nFin."

api/tests/unit_tests/core/workflow/nodes/test_if_else.py

@@ -0,0 +1,193 @@
+from unittest.mock import MagicMock
+
+from core.workflow.entities.node_entities import SystemVariable
+from core.workflow.entities.variable_pool import VariablePool
+from core.workflow.nodes.base_node import UserFrom
+from core.workflow.nodes.if_else.if_else_node import IfElseNode
+from extensions.ext_database import db
+from models.workflow import WorkflowNodeExecutionStatus
+
+
+def test_execute_if_else_result_true():
+    node = IfElseNode(
+        tenant_id='1',
+        app_id='1',
+        workflow_id='1',
+        user_id='1',
+        user_from=UserFrom.ACCOUNT,
+        config={
+            'id': 'if-else',
+            'data': {
+                'title': '123',
+                'type': 'if-else',
+                'logical_operator': 'and',
+                'conditions': [
+                    {
+                        'comparison_operator': 'contains',
+                        'variable_selector': ['start', 'array_contains'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': 'not contains',
+                        'variable_selector': ['start', 'array_not_contains'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': 'contains',
+                        'variable_selector': ['start', 'contains'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': 'not contains',
+                        'variable_selector': ['start', 'not_contains'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': 'start with',
+                        'variable_selector': ['start', 'start_with'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': 'end with',
+                        'variable_selector': ['start', 'end_with'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': 'is',
+                        'variable_selector': ['start', 'is'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': 'is not',
+                        'variable_selector': ['start', 'is_not'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': 'empty',
+                        'variable_selector': ['start', 'empty'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': 'not empty',
+                        'variable_selector': ['start', 'not_empty'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': '=',
+                        'variable_selector': ['start', 'equals'],
+                        'value': '22'
+                    },
+                    {
+                        'comparison_operator': '≠',
+                        'variable_selector': ['start', 'not_equals'],
+                        'value': '22'
+                    },
+                    {
+                        'comparison_operator': '>',
+                        'variable_selector': ['start', 'greater_than'],
+                        'value': '22'
+                    },
+                    {
+                        'comparison_operator': '<',
+                        'variable_selector': ['start', 'less_than'],
+                        'value': '22'
+                    },
+                    {
+                        'comparison_operator': '≥',
+                        'variable_selector': ['start', 'greater_than_or_equal'],
+                        'value': '22'
+                    },
+                    {
+                        'comparison_operator': '≤',
+                        'variable_selector': ['start', 'less_than_or_equal'],
+                        'value': '22'
+                    },
+                    {
+                        'comparison_operator': 'null',
+                        'variable_selector': ['start', 'null']
+                    },
+                    {
+                        'comparison_operator': 'not null',
+                        'variable_selector': ['start', 'not_null']
+                    },
+                ]
+            }
+        }
+    )
+
+    # construct variable pool
+    pool = VariablePool(system_variables={
+        SystemVariable.FILES: [],
+    }, user_inputs={})
+    pool.append_variable(node_id='start', variable_key_list=['array_contains'], value=['ab', 'def'])
+    pool.append_variable(node_id='start', variable_key_list=['array_not_contains'], value=['ac', 'def'])
+    pool.append_variable(node_id='start', variable_key_list=['contains'], value='cabcde')
+    pool.append_variable(node_id='start', variable_key_list=['not_contains'], value='zacde')
+    pool.append_variable(node_id='start', variable_key_list=['start_with'], value='abc')
+    pool.append_variable(node_id='start', variable_key_list=['end_with'], value='zzab')
+    pool.append_variable(node_id='start', variable_key_list=['is'], value='ab')
+    pool.append_variable(node_id='start', variable_key_list=['is_not'], value='aab')
+    pool.append_variable(node_id='start', variable_key_list=['empty'], value='')
+    pool.append_variable(node_id='start', variable_key_list=['not_empty'], value='aaa')
+    pool.append_variable(node_id='start', variable_key_list=['equals'], value=22)
+    pool.append_variable(node_id='start', variable_key_list=['not_equals'], value=23)
+    pool.append_variable(node_id='start', variable_key_list=['greater_than'], value=23)
+    pool.append_variable(node_id='start', variable_key_list=['less_than'], value=21)
+    pool.append_variable(node_id='start', variable_key_list=['greater_than_or_equal'], value=22)
+    pool.append_variable(node_id='start', variable_key_list=['less_than_or_equal'], value=21)
+    pool.append_variable(node_id='start', variable_key_list=['not_null'], value='1212')
+
+    # Mock db.session.close()
+    db.session.close = MagicMock()
+
+    # execute node
+    result = node._run(pool)
+
+    assert result.status == WorkflowNodeExecutionStatus.SUCCEEDED
+    assert result.outputs['result'] is True
+
+
+def test_execute_if_else_result_false():
+    node = IfElseNode(
+        tenant_id='1',
+        app_id='1',
+        workflow_id='1',
+        user_id='1',
+        user_from=UserFrom.ACCOUNT,
+        config={
+            'id': 'if-else',
+            'data': {
+                'title': '123',
+                'type': 'if-else',
+                'logical_operator': 'or',
+                'conditions': [
+                    {
+                        'comparison_operator': 'contains',
+                        'variable_selector': ['start', 'array_contains'],
+                        'value': 'ab'
+                    },
+                    {
+                        'comparison_operator': 'not contains',
+                        'variable_selector': ['start', 'array_not_contains'],
+                        'value': 'ab'
+                    }
+                ]
+            }
+        }
+    )
+
+    # construct variable pool
+    pool = VariablePool(system_variables={
+        SystemVariable.FILES: [],
+    }, user_inputs={})
+    pool.append_variable(node_id='start', variable_key_list=['array_contains'], value=['1ab', 'def'])
+    pool.append_variable(node_id='start', variable_key_list=['array_not_contains'], value=['ab', 'def'])
+
+    # Mock db.session.close()
+    db.session.close = MagicMock()
+
+    # execute node
+    result = node._run(pool)
+
+    assert result.status == WorkflowNodeExecutionStatus.SUCCEEDED
+    assert result.outputs['result'] is False