# -*- coding: UTF-8 -*- # Author: Eternity # @Email: 1533512157@qq.com # @Time : 2026/2/6 import pytest from app.core.workflow.nodes import IfElseNode from app.core.workflow.variable.base_variable import VariableType from tests.workflow.nodes.base import simple_state, simple_vairable_pool # 字符串比较测试配置 STRING_EQ_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "eq", "right": "hello", "input_type": "constant" } ] } ] } } STRING_CONTAINS_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "contains", "right": "world", "input_type": "constant" } ] } ] } } STRING_STARTSWITH_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "startwith", "right": "hello", "input_type": "constant" } ] } ] } } STRING_ENDSWITH_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "endwith", "right": "world", "input_type": "constant" } ] } ] } } STRING_EMPTY_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "empty", "right": "", "input_type": "constant" } ] } ] } } STRING_NOT_EMPTY_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "not_empty", "right": "", "input_type": "constant" } ] } ] } } # 数字比较测试配置 NUMBER_EQ_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "eq", "right": 10, "input_type": "constant" } ] } ] } } NUMBER_LT_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "lt", "right": 10, "input_type": "constant" } ] } ] } } NUMBER_GT_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "gt", "right": 10, "input_type": "constant" } ] } ] } } NUMBER_LE_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "le", "right": 10, "input_type": "constant" } ] } ] } } NUMBER_GE_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "ge", "right": 10, "input_type": "constant" } ] } ] } } # 布尔比较测试配置 BOOLEAN_EQ_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "eq", "right": True, "input_type": "constant" } ] } ] } } # 数组比较测试配置 ARRAY_CONTAINS_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "contains", "right": 2, "input_type": "constant" } ] } ] } } ARRAY_EMPTY_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "empty", "right": "", "input_type": "constant" } ] } ] } } # 对象比较测试配置 OBJECT_EMPTY_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "empty", "right": "", "input_type": "constant" } ] } ] } } # 多条件测试配置 MULTI_CONDITION_AND_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test1}}", "operator": "eq", "right": 10, "input_type": "constant" }, { "left": "{{conv.test2}}", "operator": "eq", "right": "hello", "input_type": "constant" } ] } ] } } MULTI_CONDITION_OR_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "or", "expressions": [ { "left": "{{conv.test1}}", "operator": "eq", "right": 10, "input_type": "constant" }, { "left": "{{conv.test2}}", "operator": "eq", "right": "hello", "input_type": "constant" } ] } ] } } # 多分支测试配置 MULTI_BRANCH_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "eq", "right": 1, "input_type": "constant" } ] }, { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "eq", "right": 2, "input_type": "constant" } ] }, { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "eq", "right": 3, "input_type": "constant" } ] } ] } } # 变量引用测试配置 VARIABLE_REFERENCE_CONFIG = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test1}}", "operator": "eq", "right": "{{conv.test2}}", "input_type": "variable" } ] } ] } } # ==================== 字符串比较测试 ==================== @pytest.mark.asyncio async def test_ifelse_string_eq_true(): """测试字符串相等条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "hello", VariableType.STRING, mut=True) result = await IfElseNode(STRING_EQ_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_string_eq_false(): """测试字符串相等条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "world", VariableType.STRING, mut=True) result = await IfElseNode(STRING_EQ_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_string_contains_true(): """测试字符串包含条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "hello world", VariableType.STRING, mut=True) result = await IfElseNode(STRING_CONTAINS_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_string_contains_false(): """测试字符串包含条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "hello", VariableType.STRING, mut=True) result = await IfElseNode(STRING_CONTAINS_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_string_startswith_true(): """测试字符串开头匹配条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "hello world", VariableType.STRING, mut=True) result = await IfElseNode(STRING_STARTSWITH_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_string_startswith_false(): """测试字符串开头匹配条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "world hello", VariableType.STRING, mut=True) result = await IfElseNode(STRING_STARTSWITH_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_string_endswith_true(): """测试字符串结尾匹配条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "hello world", VariableType.STRING, mut=True) result = await IfElseNode(STRING_ENDSWITH_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_string_endswith_false(): """测试字符串结尾匹配条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "world hello", VariableType.STRING, mut=True) result = await IfElseNode(STRING_ENDSWITH_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_string_empty_true(): """测试字符串为空条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "", VariableType.STRING, mut=True) result = await IfElseNode(STRING_EMPTY_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_string_empty_false(): """测试字符串为空条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "hello", VariableType.STRING, mut=True) result = await IfElseNode(STRING_EMPTY_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_string_not_empty_true(): """测试字符串非空条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "hello", VariableType.STRING, mut=True) result = await IfElseNode(STRING_NOT_EMPTY_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_string_not_empty_false(): """测试字符串非空条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "", VariableType.STRING, mut=True) result = await IfElseNode(STRING_NOT_EMPTY_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" # ==================== 数字比较测试 ==================== @pytest.mark.asyncio async def test_ifelse_number_eq_true(): """测试数字相等条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 10, VariableType.NUMBER, mut=True) result = await IfElseNode(NUMBER_EQ_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_number_eq_false(): """测试数字相等条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 5, VariableType.NUMBER, mut=True) result = await IfElseNode(NUMBER_EQ_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_number_lt_true(): """测试数字小于条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 5, VariableType.NUMBER, mut=True) result = await IfElseNode(NUMBER_LT_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_number_lt_false(): """测试数字小于条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 15, VariableType.NUMBER, mut=True) result = await IfElseNode(NUMBER_LT_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_number_gt_true(): """测试数字大于条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 15, VariableType.NUMBER, mut=True) result = await IfElseNode(NUMBER_GT_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_number_gt_false(): """测试数字大于条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 5, VariableType.NUMBER, mut=True) result = await IfElseNode(NUMBER_GT_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_number_le_true(): """测试数字小于等于条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 10, VariableType.NUMBER, mut=True) result = await IfElseNode(NUMBER_LE_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_number_le_false(): """测试数字小于等于条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 15, VariableType.NUMBER, mut=True) result = await IfElseNode(NUMBER_LE_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_number_ge_true(): """测试数字大于等于条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 10, VariableType.NUMBER, mut=True) result = await IfElseNode(NUMBER_GE_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_number_ge_false(): """测试数字大于等于条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 5, VariableType.NUMBER, mut=True) result = await IfElseNode(NUMBER_GE_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" # ==================== 布尔比较测试 ==================== @pytest.mark.asyncio async def test_ifelse_boolean_eq_true(): """测试布尔值相等条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", True, VariableType.BOOLEAN, mut=True) result = await IfElseNode(BOOLEAN_EQ_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_boolean_eq_false(): """测试布尔值相等条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", False, VariableType.BOOLEAN, mut=True) result = await IfElseNode(BOOLEAN_EQ_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" # ==================== 数组比较测试 ==================== @pytest.mark.asyncio async def test_ifelse_array_contains_true(): """测试数组包含条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", [1, 2, 3], VariableType.ARRAY_NUMBER, mut=True) result = await IfElseNode(ARRAY_CONTAINS_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_array_contains_false(): """测试数组包含条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", [1, 3, 4], VariableType.ARRAY_NUMBER, mut=True) result = await IfElseNode(ARRAY_CONTAINS_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_array_empty_true(): """测试数组为空条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", [], VariableType.ARRAY_NUMBER, mut=True) result = await IfElseNode(ARRAY_EMPTY_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_array_empty_false(): """测试数组为空条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", [1, 2], VariableType.ARRAY_NUMBER, mut=True) result = await IfElseNode(ARRAY_EMPTY_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" # ==================== 对象比较测试 ==================== @pytest.mark.asyncio async def test_ifelse_object_empty_true(): """测试对象为空条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", {}, VariableType.OBJECT, mut=True) result = await IfElseNode(OBJECT_EMPTY_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_object_empty_false(): """测试对象为空条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", {"key": "value"}, VariableType.OBJECT, mut=True) result = await IfElseNode(OBJECT_EMPTY_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" # ==================== 多条件测试 ==================== @pytest.mark.asyncio async def test_ifelse_multi_condition_and_all_true(): """测试多条件AND逻辑，所有条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test1", 10, VariableType.NUMBER, mut=True) await variable_pool.new("conv", "test2", "hello", VariableType.STRING, mut=True) result = await IfElseNode(MULTI_CONDITION_AND_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_multi_condition_and_one_false(): """测试多条件AND逻辑，一个条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test1", 10, VariableType.NUMBER, mut=True) await variable_pool.new("conv", "test2", "world", VariableType.STRING, mut=True) result = await IfElseNode(MULTI_CONDITION_AND_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_multi_condition_and_all_false(): """测试多条件AND逻辑，所有条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test1", 5, VariableType.NUMBER, mut=True) await variable_pool.new("conv", "test2", "world", VariableType.STRING, mut=True) result = await IfElseNode(MULTI_CONDITION_AND_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_multi_condition_or_all_true(): """测试多条件OR逻辑，所有条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test1", 10, VariableType.NUMBER, mut=True) await variable_pool.new("conv", "test2", "hello", VariableType.STRING, mut=True) result = await IfElseNode(MULTI_CONDITION_OR_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_multi_condition_or_one_true(): """测试多条件OR逻辑，一个条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test1", 10, VariableType.NUMBER, mut=True) await variable_pool.new("conv", "test2", "world", VariableType.STRING, mut=True) result = await IfElseNode(MULTI_CONDITION_OR_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_multi_condition_or_all_false(): """测试多条件OR逻辑，所有条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test1", 5, VariableType.NUMBER, mut=True) await variable_pool.new("conv", "test2", "world", VariableType.STRING, mut=True) result = await IfElseNode(MULTI_CONDITION_OR_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" # ==================== 多分支测试 ==================== @pytest.mark.asyncio async def test_ifelse_multi_branch_first(): """测试多分支，匹配第一个分支""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 1, VariableType.NUMBER, mut=True) result = await IfElseNode(MULTI_BRANCH_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_multi_branch_second(): """测试多分支，匹配第二个分支""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 2, VariableType.NUMBER, mut=True) result = await IfElseNode(MULTI_BRANCH_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_multi_branch_third(): """测试多分支，匹配第三个分支""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 3, VariableType.NUMBER, mut=True) result = await IfElseNode(MULTI_BRANCH_CONFIG, {}).execute(state, variable_pool) assert result == "CASE3" @pytest.mark.asyncio async def test_ifelse_multi_branch_default(): """测试多分支，匹配默认分支""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 4, VariableType.NUMBER, mut=True) result = await IfElseNode(MULTI_BRANCH_CONFIG, {}).execute(state, variable_pool) assert result == "CASE4" # ==================== 变量引用测试 ==================== @pytest.mark.asyncio async def test_ifelse_variable_reference_true(): """测试变量引用条件为真""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test1", 10, VariableType.NUMBER, mut=True) await variable_pool.new("conv", "test2", 10, VariableType.NUMBER, mut=True) result = await IfElseNode(VARIABLE_REFERENCE_CONFIG, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_variable_reference_false(): """测试变量引用条件为假""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test1", 10, VariableType.NUMBER, mut=True) await variable_pool.new("conv", "test2", 20, VariableType.NUMBER, mut=True) result = await IfElseNode(VARIABLE_REFERENCE_CONFIG, {}).execute(state, variable_pool) assert result == "CASE2" # ==================== 边界情况测试 ==================== @pytest.mark.asyncio async def test_ifelse_none_variable(): """测试变量不存在的情况""" state = simple_state() variable_pool = await simple_vairable_pool("test") config = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.nonexistent}}", "operator": "eq", "right": 10, "input_type": "constant" } ] } ] } } result = await IfElseNode(config, {}).execute(state, variable_pool) assert result == "CASE2" @pytest.mark.asyncio async def test_ifelse_float_comparison(): """测试浮点数比较""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 10.5, VariableType.NUMBER, mut=True) config = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "gt", "right": 10.0, "input_type": "constant" } ] } ] } } result = await IfElseNode(config, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_string_ne(): """测试字符串不等于""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "hello", VariableType.STRING, mut=True) config = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "ne", "right": "world", "input_type": "constant" } ] } ] } } result = await IfElseNode(config, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_number_ne(): """测试数字不等于""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", 10, VariableType.NUMBER, mut=True) config = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "ne", "right": 5, "input_type": "constant" } ] } ] } } result = await IfElseNode(config, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_array_not_contains(): """测试数组不包含""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", [1, 2, 3], VariableType.ARRAY_NUMBER, mut=True) config = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "not_contains", "right": 5, "input_type": "constant" } ] } ] } } result = await IfElseNode(config, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_string_not_contains(): """测试字符串不包含""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", "hello", VariableType.STRING, mut=True) config = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "not_contains", "right": "world", "input_type": "constant" } ] } ] } } result = await IfElseNode(config, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_object_not_empty(): """测试对象非空""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", {"key": "value"}, VariableType.OBJECT, mut=True) config = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "not_empty", "right": "", "input_type": "constant" } ] } ] } } result = await IfElseNode(config, {}).execute(state, variable_pool) assert result == "CASE1" @pytest.mark.asyncio async def test_ifelse_array_not_empty(): """测试数组非空""" state = simple_state() variable_pool = await simple_vairable_pool("test") await variable_pool.new("conv", "test", [1, 2], VariableType.ARRAY_NUMBER, mut=True) config = { "id": "ifelse_test", "type": "if-else", "name": "条件测试节点", "config": { "cases": [ { "logical_operator": "and", "expressions": [ { "left": "{{conv.test}}", "operator": "not_empty", "right": "", "input_type": "constant" } ] } ] } } result = await IfElseNode(config, {}).execute(state, variable_pool) assert result == "CASE1"