WeKnora deployment source with the reviewed wiki identity, summary and recovery fixes

internal/workbench/configuration_test.go

@@ -0,0 +1,190 @@
+package workbench
+
+import (
+	"context"
+	"encoding/base64"
+	"encoding/json"
+	"errors"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	"github.com/Tencent/WeKnora/internal/models/vlm"
+	"github.com/Tencent/WeKnora/internal/types"
+	"github.com/Tencent/WeKnora/internal/types/interfaces"
+	"github.com/gin-gonic/gin"
+)
+
+func updateWorkbenchResource(s *Service, ctx context.Context, r *Resource, request resourceRequest) *httptest.ResponseRecorder {
+	w := httptest.NewRecorder()
+	c, _ := gin.CreateTestContext(w)
+	data, _ := json.Marshal(request)
+	c.Request = httptest.NewRequest(http.MethodPut, "/", strings.NewReader(string(data))).WithContext(ctx)
+	c.Request.Header.Set("Content-Type", "application/json")
+	c.Params = gin.Params{{Key: "kind", Value: r.Kind}, {Key: "id", Value: r.ID}}
+	NewHandler(s).Update(c)
+	return w
+}
+
+func TestImportedResourceRenameConfigurationActivationAndSpoofProtection(t *testing.T) {
+	s := sqliteWorkbench(t)
+	s.agents = generationAgentStub{}
+	ctx := workbenchContext(1, "alice", types.TenantRoleContributor)
+	r := seedResource(t, s, 1, "alice", "flows")
+	r.Status = "needs_configuration"
+	r.Data = JSON{"legacy_import": JSON{"read_only": true, "needs_configuration": true}, "legacy_history": JSON{"original": "preserved"}, "nodes": []FlowNode{}, "edges": []FlowEdge{}}
+	if err := s.db.Save(r).Error; err != nil {
+		t.Fatal(err)
+	}
+	original := compact(r.Data)
+	if w := updateWorkbenchResource(s, ctx, r, resourceRequest{Name: "renamed", Version: 1, Data: r.Data}); w.Code != 200 {
+		t.Fatal(w.Code, w.Body.String())
+	}
+	r, _ = s.get(ctx, r.Kind, r.ID)
+	if requireExecutable(r) == nil {
+		t.Fatal("rename activated incomplete import")
+	}
+	forged := resourceData(r, r.Data)
+	forged["legacy_activation"] = JSON{"status": "active"}
+	if w := updateWorkbenchResource(s, ctx, r, resourceRequest{Name: r.Name, Version: r.Version, Data: forged, Configure: true}); w.Code != 400 {
+		t.Fatal("forged activation accepted")
+	}
+	if w := updateWorkbenchResource(s, ctx, r, resourceRequest{Name: r.Name, Version: r.Version, Data: r.Data, Configure: true}); w.Code != 400 {
+		t.Fatal("empty canvas activated")
+	}
+	configured := resourceData(r, FlowData{Nodes: []FlowNode{{ID: "n1", AgentID: "author"}}})
+	if w := updateWorkbenchResource(s, ctx, r, resourceRequest{Name: r.Name, Version: r.Version, Data: configured, Configure: true}); w.Code != 200 {
+		t.Fatal(w.Code, w.Body.String())
+	}
+	r, _ = s.get(ctx, r.Kind, r.ID)
+	if err := requireExecutable(r); err != nil {
+		t.Fatal(err)
+	}
+	if compact(r.Data["legacy_history"]) != `{"original":"preserved"}` {
+		t.Fatal("history lost")
+	}
+	var revision Revision
+	if err := s.db.First(&revision, "resource_id = ? AND version = 1", r.ID).Error; err != nil || compact(revision.Data) != original {
+		t.Fatal("preedit import lost")
+	}
+}
+
+func TestTaskConfigurationKeepsHistoricalOutput(t *testing.T) {
+	d := TaskData{FlowID: "old", SourceText: "original", Segments: []Segment{{ID: "s", Content: "historical", AgentID: "a", Status: "accepted", Review: "segment review"}}, Review: "review", Composed: "final"}
+	r := &Resource{Kind: "content-tasks", Data: asJSON(d), Status: "completed"}
+	d.FlowID = "new"
+	if err := applyManualUpdate(r, resourceRequest{Name: "task", Data: asJSON(d)}); err != nil {
+		t.Fatal(err)
+	}
+	got, _ := decode[TaskData](r.Data)
+	if len(got.Segments) != 1 || got.Segments[0].Content != "historical" || got.Segments[0].Status != "needs_review" || got.Review != "review" || got.Composed != "final" || r.Status != "needs_review" {
+		t.Fatalf("output lost or stale approval retained: %+v", got)
+	}
+}
+
+func TestTextTaskInheritsAgentKnowledgeAndIgnoresLegacyCanvasScope(t *testing.T) {
+	s := sqliteWorkbench(t)
+	s.agents = generationAgentStub{config: types.CustomAgentConfig{KnowledgeBases: []string{"agent-kb"}, KBSelectionMode: "selected"}}
+	ctx := workbenchContext(1, "alice", types.TenantRoleContributor)
+	f := seedResource(t, s, 1, "alice", "flows")
+	f.Data = asJSON(FlowData{Nodes: []FlowNode{{ID: "n", AgentID: "canvas-agent"}}, KnowledgeIDs: []string{"canvas-file"}, KnowledgeFolders: map[string][]string{"kb": {"folder"}}})
+	if err := s.db.Save(f).Error; err != nil {
+		t.Fatal(err)
+	}
+	r := &Resource{Kind: "content-tasks", Name: "task", Data: asJSON(TaskData{SourceText: "manual framework", FlowID: f.ID, AgentID: "injected", KBIDs: []string{"injected-kb"}})}
+	if err := s.validate(ctx, r); err != nil {
+		t.Fatal(err)
+	}
+	d, _ := decode[TaskData](r.Data)
+	if d.AgentID != "canvas-agent" || len(d.KBIDs) != 1 || d.KBIDs[0] != "agent-kb" || len(d.KnowledgeIDs) != 0 || len(d.KnowledgeFolders) != 0 || len(d.KnowledgeTags) != 0 {
+		t.Fatalf("task did not inherit: %+v", d)
+	}
+	if err := s.inheritFlow(ctx, &d, FlowData{Nodes: []FlowNode{{ID: "n", AgentID: "canvas-agent"}}}); err != nil || len(d.KBIDs) != 1 || d.KBIDs[0] != "agent-kb" {
+		t.Fatalf("agent scope not inherited: %+v %v", d, err)
+	}
+}
+
+func TestAIRecommendsTrainingDays(t *testing.T) {
+	s, ctx, job, model := generationHarness(t)
+	job.Action = "generate"
+	model.output = `{"days":[{"day":1,"title":"first","hook":"next","nodes":[{"id":"n1","label":"foundation"}]},{"day":2,"title":"second","prerequisite":"first","hook":"apply","nodes":[{"id":"n2","label":"practice"}]}]}`
+	r := &Resource{Kind: "training-maps", Data: asJSON(MapData{Topic: "topic", AgentID: "author"})}
+	if err := s.executeMap(ctx, job, r, ActionRequest{}); err != nil {
+		t.Fatal(err)
+	}
+	d, _ := decode[MapData](r.Data)
+	if d.DaysCount != 2 || !d.DaysAuto || !strings.Contains(model.messages[1].Content, "推荐合理天数") {
+		t.Fatal("AI day recommendation not persisted")
+	}
+	if validateDays(nil, 0) == nil {
+		t.Fatal("zero recommended days accepted")
+	}
+}
+
+func TestNodeRevisionOnlyReplacesRequestedSubtree(t *testing.T) {
+	s, ctx, job, model := generationHarness(t)
+	job.Action = "revise"
+	model.output = `{"days":[{"day":1,"title":"unrequested change","hook":"unrequested","nodes":[{"id":"a","label":"changed","children":[{"id":"a1","label":"child"}]},{"id":"b","label":"unrequested sibling change"}]}]}`
+	r := &Resource{Data: asJSON(MapData{AgentID: "author", DaysCount: 1, Days: []Day{{Day: 1, Title: "original title", Hook: "original hook", Nodes: []Node{{ID: "a", Label: "before"}, {ID: "b", Label: "sibling"}}}}})}
+	if err := s.executeMap(ctx, job, r, ActionRequest{Day: 1, NodeID: "a", Advice: "fix"}); err != nil {
+		t.Fatal(err)
+	}
+	d, _ := decode[MapData](r.Data)
+	if d.Days[0].Title != "original title" || d.Days[0].Hook != "original hook" || d.Days[0].Nodes[1].Label != "sibling" || d.Days[0].Nodes[0].Label != "changed" {
+		t.Fatalf("unrelated content changed: %+v", d.Days[0])
+	}
+	if err := s.executeMap(ctx, job, r, ActionRequest{Day: 1, NodeID: "missing", Advice: "fix"}); !errors.Is(err, ErrInvalid) {
+		t.Fatal("unknown node accepted")
+	}
+}
+
+type imageModelStub struct {
+	interfaces.ModelService
+	model vlm.VLM
+	id    string
+}
+
+func (s *imageModelStub) GetVLMModel(_ context.Context, id string) (vlm.VLM, error) {
+	s.id = id
+	return s.model, nil
+}
+func (s *imageModelStub) ListModels(context.Context) ([]*types.Model, error) {
+	return []*types.Model{{ID: "workspace-vision", Type: types.ModelTypeVLLM, Status: types.ModelStatusActive}}, nil
+}
+
+type imageVLMStub struct {
+	vlm.VLM
+	seen bool
+}
+
+func (v *imageVLMStub) Predict(_ context.Context, data [][]byte, prompt string) (string, error) {
+	v.seen = len(data) == 1 && strings.Contains(prompt, "节点")
+	return "# recognized framework", nil
+}
+
+func TestImageOCRUsesAgentModelAndWorkspaceFallback(t *testing.T) {
+	image := "data:image/png;base64," + base64.StdEncoding.EncodeToString([]byte("\x89PNG\r\n\x1a\nimage"))
+	for _, configured := range []string{"agent-vision", ""} {
+		s := NewService(nil)
+		v := &imageVLMStub{}
+		m := &imageModelStub{model: v}
+		s.models, s.agents = m, generationAgentStub{config: types.CustomAgentConfig{VLMModelID: configured}}
+		text, err := s.recognizeSourceImage(workbenchContext(1, "alice", types.TenantRoleContributor), "agent", image)
+		if err != nil || text != "# recognized framework" || !v.seen {
+			t.Fatal(text, err)
+		}
+		want := configured
+		if want == "" {
+			want = "workspace-vision"
+		}
+		if m.id != want {
+			t.Fatal("wrong VLM", m.id)
+		}
+	}
+	for _, invalid := range []string{"https://external/image.png", "data:image/png;base64,not-base64", "data:image/png;base64," + base64.StdEncoding.EncodeToString([]byte("text"))} {
+		if _, err := decodeSourceImage(invalid); err == nil {
+			t.Fatal("invalid image accepted")
+		}
+	}
+}