mirror of
https://github.com/infiniflow/ragflow.git
synced 2026-06-29 23:41:12 +08:00
f58fae5fb7
Ported retrieval node, added Keenable web search tool - [x] New Feature (non-breaking change which adds functionality)
423 lines
12 KiB
Go
423 lines
12 KiB
Go
//
|
|
// Copyright 2026 The InfiniFlow Authors. All Rights Reserved.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
//
|
|
|
|
package component
|
|
|
|
import (
|
|
"context"
|
|
"testing"
|
|
|
|
"ragflow/internal/agent/canvas"
|
|
)
|
|
|
|
// nextTargets extracts the _next field as a list of target cpn_ids.
|
|
// Switch.Invoke now returns _next as []any (list of strings) to
|
|
// support Python's multi-target "to" field.
|
|
func nextTargets(out map[string]any) []string {
|
|
raw, ok := out["_next"]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
switch v := raw.(type) {
|
|
case []any:
|
|
targets := make([]string, 0, len(v))
|
|
for _, item := range v {
|
|
if s, ok := item.(string); ok && s != "" {
|
|
targets = append(targets, s)
|
|
}
|
|
}
|
|
return targets
|
|
case string:
|
|
if v != "" {
|
|
return []string{v}
|
|
}
|
|
return nil
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// TestSwitch_AndMatches: a single-condition AND group with a sys
|
|
// reference that matches the state must route to "matched_0" (the
|
|
// fallback name when no explicit "to" is provided).
|
|
func TestSwitch_AndMatches(t *testing.T) {
|
|
s, _ := NewSwitchComponent(nil)
|
|
state := canvas.NewCanvasState("run-1", "task-1")
|
|
state.Sys["x"] = "yes"
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
inputs := map[string]any{
|
|
"conditions": []any{
|
|
map[string]any{
|
|
"op": "and",
|
|
"clauses": []any{
|
|
map[string]any{"left": "{{sys.x}}", "op": "==", "right": "yes"},
|
|
},
|
|
},
|
|
},
|
|
"default": "fallback",
|
|
}
|
|
out, err := s.Invoke(ctx, inputs)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 1 || targets[0] != "matched_0" {
|
|
t.Errorf("_next: got %v, want [\"matched_0\"]", targets)
|
|
}
|
|
}
|
|
|
|
// TestSwitch_OrMatches: an OR group with one false clause and one
|
|
// true clause must match. Also covers explicit "to" routing and
|
|
// multi-clause groups.
|
|
func TestSwitch_OrMatches(t *testing.T) {
|
|
s, _ := NewSwitchComponent(nil)
|
|
state := canvas.NewCanvasState("run-2", "task-2")
|
|
state.Sys["score"] = "85"
|
|
state.Sys["flag"] = "no"
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
inputs := map[string]any{
|
|
"conditions": []any{
|
|
// First group: AND of two clauses, both must be true.
|
|
// score != "85" is false → AND fails → no match.
|
|
map[string]any{
|
|
"op": "and",
|
|
"clauses": []any{
|
|
map[string]any{"left": "{{sys.score}}", "op": "==", "right": "100"},
|
|
map[string]any{"left": "{{sys.flag}}", "op": "==", "right": "yes"},
|
|
},
|
|
},
|
|
// Second group: OR; first clause is false but second
|
|
// is true → match → route to "match_route".
|
|
map[string]any{
|
|
"op": "or",
|
|
"to": "match_route",
|
|
"clauses": []any{
|
|
map[string]any{"left": "{{sys.flag}}", "op": "==", "right": "yes"},
|
|
map[string]any{"left": "{{sys.score}}", "op": "==", "right": "85"},
|
|
},
|
|
},
|
|
},
|
|
"default": "fallback",
|
|
}
|
|
out, err := s.Invoke(ctx, inputs)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 1 || targets[0] != "match_route" {
|
|
t.Errorf("_next: got %v, want [\"match_route\"]", targets)
|
|
}
|
|
}
|
|
|
|
// TestSwitch_DefaultFallback: when no condition matches, the default
|
|
// cpn_id from inputs["default"] is returned.
|
|
func TestSwitch_DefaultFallback(t *testing.T) {
|
|
s, _ := NewSwitchComponent(nil)
|
|
state := canvas.NewCanvasState("run-3", "task-3")
|
|
state.Sys["x"] = "no"
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
inputs := map[string]any{
|
|
"conditions": []any{
|
|
map[string]any{
|
|
"op": "and",
|
|
"clauses": []any{
|
|
map[string]any{"left": "{{sys.x}}", "op": "==", "right": "yes"},
|
|
},
|
|
},
|
|
},
|
|
"default": "fallback_0",
|
|
}
|
|
out, err := s.Invoke(ctx, inputs)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 1 || targets[0] != "fallback_0" {
|
|
t.Errorf("_next: got %v, want [\"fallback_0\"]", targets)
|
|
}
|
|
}
|
|
|
|
func TestSwitch_LegacyEndCpnIDsFallback(t *testing.T) {
|
|
s, _ := NewSwitchComponent(nil)
|
|
state := canvas.NewCanvasState("run-end-cpn", "task-end-cpn")
|
|
state.Sys["x"] = "no"
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
inputs := map[string]any{
|
|
"conditions": []any{
|
|
map[string]any{
|
|
"logical_operator": "and",
|
|
"items": []any{
|
|
map[string]any{"cpn_id": "sys.x", "operator": "=", "value": "yes"},
|
|
},
|
|
},
|
|
},
|
|
"end_cpn_ids": []any{"legacy_fallback"},
|
|
}
|
|
out, err := s.Invoke(ctx, inputs)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 1 || targets[0] != "legacy_fallback" {
|
|
t.Errorf("_next: got %v, want [\"legacy_fallback\"]", targets)
|
|
}
|
|
}
|
|
|
|
// TestSwitch_ContainsAndEmpty covers two operators that are easy to
|
|
// regress: "contains" (substring match) and "empty" (nil/empty test).
|
|
func TestSwitch_ContainsAndEmpty(t *testing.T) {
|
|
s, _ := NewSwitchComponent(nil)
|
|
state := canvas.NewCanvasState("run-4", "task-4")
|
|
state.Sys["body"] = "hello world"
|
|
state.Sys["opt"] = ""
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
inputs := map[string]any{
|
|
"conditions": []any{
|
|
map[string]any{
|
|
"op": "and",
|
|
"clauses": []any{
|
|
map[string]any{"left": "{{sys.body}}", "op": "contains", "right": "world"},
|
|
map[string]any{"left": "{{sys.opt}}", "op": "empty"},
|
|
},
|
|
},
|
|
},
|
|
"default": "x",
|
|
}
|
|
out, err := s.Invoke(ctx, inputs)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 1 || targets[0] != "matched_0" {
|
|
t.Errorf("_next: got %v, want [\"matched_0\"]", targets)
|
|
}
|
|
}
|
|
|
|
func TestSwitch_LegacyConditionsAndArrayTo(t *testing.T) {
|
|
s, _ := NewSwitchComponent(map[string]any{
|
|
"conditions": []any{
|
|
map[string]any{
|
|
"logical_operator": "and",
|
|
"items": []any{
|
|
map[string]any{
|
|
"cpn_id": "UserFillUp:Menu@demo",
|
|
"operator": "=",
|
|
"value": "loop",
|
|
},
|
|
},
|
|
"to": []any{"Loop:InputUntil1"},
|
|
},
|
|
},
|
|
"default": "Message:Help",
|
|
})
|
|
state := canvas.NewCanvasState("run-legacy", "task-legacy")
|
|
state.SetVar("UserFillUp:Menu", "demo", "loop")
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
out, err := s.Invoke(ctx, nil)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 1 || targets[0] != "Loop:InputUntil1" {
|
|
t.Errorf("_next: got %v, want [\"Loop:InputUntil1\"]", targets)
|
|
}
|
|
}
|
|
|
|
// TestSwitch_NilUpstreamContainsEmptyNeedleMatches ports the
|
|
// regression covered by python PR #16320: when an upstream
|
|
// component yields nil and the configured value is the empty
|
|
// string, the "contains" operator must match (Python semantics
|
|
// after the fix: "" in "anything"). Pre-fix Python crashed with
|
|
// AttributeError; pre-port Go returned false because fmt rendered
|
|
// nil as "<nil>" instead of "". The fix coerces nil → "" before
|
|
// formatting, restoring parity with the Python workflow.
|
|
func TestSwitch_NilUpstreamContainsEmptyNeedleMatches(t *testing.T) {
|
|
s, _ := NewSwitchComponent(nil)
|
|
state := canvas.NewCanvasState("run-nil-contains", "task-nil-contains")
|
|
state.Sys["answer"] = nil
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
inputs := map[string]any{
|
|
"conditions": []any{
|
|
map[string]any{
|
|
"op": "and",
|
|
"to": []any{"case_target"},
|
|
"clauses": []any{
|
|
map[string]any{"left": "{{sys.answer}}", "op": "contains", "right": ""},
|
|
},
|
|
},
|
|
},
|
|
"default": "else_target",
|
|
}
|
|
out, err := s.Invoke(ctx, inputs)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 1 || targets[0] != "case_target" {
|
|
t.Errorf("_next: got %v, want [\"case_target\"] (nil coerced to \"\" should match empty needle)", targets)
|
|
}
|
|
}
|
|
|
|
// TestSwitch_NilUpstreamContainsNonEmptyDoesNotMatch verifies
|
|
// the inverse: nil coerced to "" still must NOT match a
|
|
// non-empty needle (we only coerce, we don't synthesize a match).
|
|
func TestSwitch_NilUpstreamContainsNonEmptyDoesNotMatch(t *testing.T) {
|
|
s, _ := NewSwitchComponent(nil)
|
|
state := canvas.NewCanvasState("run-nil-needle", "task-nil-needle")
|
|
state.Sys["answer"] = nil
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
inputs := map[string]any{
|
|
"conditions": []any{
|
|
map[string]any{
|
|
"op": "and",
|
|
"to": []any{"case_target"},
|
|
"clauses": []any{
|
|
map[string]any{"left": "{{sys.answer}}", "op": "contains", "right": "foo"},
|
|
},
|
|
},
|
|
},
|
|
"default": "else_target",
|
|
}
|
|
out, err := s.Invoke(ctx, inputs)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 1 || targets[0] != "else_target" {
|
|
t.Errorf("_next: got %v, want [\"else_target\"] (\"\" does not contain \"foo\")", targets)
|
|
}
|
|
}
|
|
|
|
// TestSwitch_NilValueContainsDoesNotRaise mirrors python test
|
|
// "test_switch_none_value_contains_does_not_raise": the configured
|
|
// value can also be nil and the operator must not crash. With
|
|
// nil coerced to "" on both sides, "foobar" contains "" matches.
|
|
func TestSwitch_NilValueContainsDoesNotRaise(t *testing.T) {
|
|
s, _ := NewSwitchComponent(nil)
|
|
state := canvas.NewCanvasState("run-nil-value", "task-nil-value")
|
|
state.Sys["answer"] = "foobar"
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
inputs := map[string]any{
|
|
"conditions": []any{
|
|
map[string]any{
|
|
"op": "and",
|
|
"to": []any{"case_target"},
|
|
"clauses": []any{
|
|
map[string]any{"left": "{{sys.answer}}", "op": "contains", "right": nil},
|
|
},
|
|
},
|
|
},
|
|
"default": "else_target",
|
|
}
|
|
out, err := s.Invoke(ctx, inputs)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 1 || targets[0] != "case_target" {
|
|
t.Errorf("_next: got %v, want [\"case_target\"] (nil value coerced to \"\" matches any string)", targets)
|
|
}
|
|
}
|
|
|
|
// TestSwitch_NilUpstreamStartWithEndWithDoNotCrash guards the
|
|
// remaining two string operators covered by PR #16320. They were
|
|
// crash-prone in Python for the same reason; in Go they don't
|
|
// crash but the nil → "" coercion still applies, so a nil
|
|
// upstream with an empty prefix/suffix must match (rather than
|
|
// being rendered as "<nil>" and silently missing).
|
|
func TestSwitch_NilUpstreamStartWithEndWithDoNotCrash(t *testing.T) {
|
|
s, _ := NewSwitchComponent(nil)
|
|
state := canvas.NewCanvasState("run-nil-start-end", "task-nil-start-end")
|
|
state.Sys["answer"] = nil
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
for _, tc := range []struct {
|
|
name string
|
|
op string
|
|
}{
|
|
{name: "start with", op: "start with"},
|
|
{name: "end with", op: "end with"},
|
|
} {
|
|
t.Run(tc.name, func(t *testing.T) {
|
|
inputs := map[string]any{
|
|
"conditions": []any{
|
|
map[string]any{
|
|
"op": "and",
|
|
"to": []any{"case_target"},
|
|
"clauses": []any{
|
|
map[string]any{"left": "{{sys.answer}}", "op": tc.op, "right": ""},
|
|
},
|
|
},
|
|
},
|
|
"default": "else_target",
|
|
}
|
|
out, err := s.Invoke(ctx, inputs)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 1 || targets[0] != "case_target" {
|
|
t.Errorf("_next: got %v, want [\"case_target\"] (nil coerced to \"\" %s \"\")", targets, tc.op)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
// TestSwitch_MultiTargetTo verifies that Switch returns all cpn_ids
|
|
// from a multi-element "to" field. This mirrors Python's behavior
|
|
// where a condition can route to multiple downstream nodes
|
|
// simultaneously (e.g. "data_ops" → ["DataOperations:UpdateSample",
|
|
// "ListOperations:Top2"]).
|
|
func TestSwitch_MultiTargetTo(t *testing.T) {
|
|
s, _ := NewSwitchComponent(nil)
|
|
state := canvas.NewCanvasState("run-multi", "task-multi")
|
|
state.SetVar("UserFillUp:Menu", "demo", "data_ops")
|
|
ctx := withStateForTest(context.Background(), state)
|
|
|
|
inputs := map[string]any{
|
|
"conditions": []any{
|
|
map[string]any{
|
|
"logical_operator": "and",
|
|
"items": []any{
|
|
map[string]any{
|
|
"cpn_id": "UserFillUp:Menu@demo",
|
|
"operator": "=",
|
|
"value": "data_ops",
|
|
},
|
|
},
|
|
"to": []any{"DataOperations:UpdateSample", "CodeExec:FunnyBronsShare"},
|
|
},
|
|
},
|
|
"default": "Message:Help",
|
|
}
|
|
out, err := s.Invoke(ctx, inputs)
|
|
if err != nil {
|
|
t.Fatalf("Invoke: %v", err)
|
|
}
|
|
targets := nextTargets(out)
|
|
if len(targets) != 2 || targets[0] != "DataOperations:UpdateSample" || targets[1] != "CodeExec:FunnyBronsShare" {
|
|
t.Errorf("_next: got %v, want [\"DataOperations:UpdateSample\", \"CodeExec:FunnyBronsShare\"]", targets)
|
|
}
|
|
}
|