fe33db9493
Persist category and hierarchy metadata on wiki pages (new migration), expose category-path retrieval and related repository/service/handler/router APIs, and update wiki ingestion (batch, cite, taxonomy) plus agent wiki prompts to build and consume the taxonomy. Regenerate swagger docs for the new endpoints.
244 lines
9.3 KiB
Go
244 lines
9.3 KiB
Go
package repository
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/Tencent/WeKnora/internal/types"
|
|
"github.com/google/uuid"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"gorm.io/driver/sqlite"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
// wikiPagesTestDDL is a minimal SQLite-compatible subset of the
|
|
// production wiki_pages DDL (migrations/versioned/000037_wiki_and_indexing.up.sql).
|
|
// JSONB is stored as TEXT in SQLite; the StringArray Scan/Value pair
|
|
// handles the JSON round-trip unchanged.
|
|
const wikiPagesTestDDL = `
|
|
CREATE TABLE IF NOT EXISTS wiki_pages (
|
|
id VARCHAR(36) PRIMARY KEY,
|
|
tenant_id INTEGER NOT NULL,
|
|
knowledge_base_id VARCHAR(36) NOT NULL,
|
|
slug VARCHAR(255) NOT NULL,
|
|
title VARCHAR(512) NOT NULL DEFAULT '',
|
|
page_type VARCHAR(32) NOT NULL DEFAULT 'summary',
|
|
status VARCHAR(32) NOT NULL DEFAULT 'published',
|
|
content TEXT NOT NULL DEFAULT '',
|
|
summary TEXT NOT NULL DEFAULT '',
|
|
parent_slug VARCHAR(255) NOT NULL DEFAULT '',
|
|
category_path TEXT DEFAULT '[]',
|
|
wiki_path VARCHAR(1024) NOT NULL DEFAULT '',
|
|
depth INTEGER NOT NULL DEFAULT 0,
|
|
sort_order INTEGER NOT NULL DEFAULT 0,
|
|
source_refs TEXT DEFAULT '[]',
|
|
chunk_refs TEXT DEFAULT '[]',
|
|
in_links TEXT DEFAULT '[]',
|
|
out_links TEXT DEFAULT '[]',
|
|
page_metadata TEXT DEFAULT '{}',
|
|
aliases TEXT DEFAULT '[]',
|
|
version INTEGER NOT NULL DEFAULT 1,
|
|
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
|
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP,
|
|
deleted_at DATETIME
|
|
);
|
|
`
|
|
|
|
func setupWikiPagesTestDB(t *testing.T) *gorm.DB {
|
|
t.Helper()
|
|
db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
|
|
require.NoError(t, err)
|
|
require.NoError(t, db.Exec(wikiPagesTestDDL).Error)
|
|
return db
|
|
}
|
|
|
|
// makeWikiPage builds a minimal WikiPage suitable for insert. Title is
|
|
// derived from the slug so ORDER BY title ASC yields a predictable
|
|
// test ordering without callers having to spell out both fields.
|
|
func makeWikiPage(kbID, slug, pageType, status string) *types.WikiPage {
|
|
title := slug
|
|
if idx := strings.LastIndex(slug, "/"); idx >= 0 {
|
|
title = slug[idx+1:]
|
|
}
|
|
return &types.WikiPage{
|
|
ID: uuid.New().String(),
|
|
TenantID: 1,
|
|
KnowledgeBaseID: kbID,
|
|
Slug: slug,
|
|
Title: title,
|
|
PageType: pageType,
|
|
Status: status,
|
|
Content: "body of " + slug,
|
|
Summary: "summary of " + slug,
|
|
WikiPath: pageType + "/" + title,
|
|
Version: 1,
|
|
CreatedAt: time.Now(),
|
|
UpdatedAt: time.Now(),
|
|
}
|
|
}
|
|
|
|
func makeCategorizedWikiPage(kbID, slug, pageType, status string, categoryPath ...string) *types.WikiPage {
|
|
page := makeWikiPage(kbID, slug, pageType, status)
|
|
page.CategoryPath = types.StringArray(categoryPath)
|
|
if len(categoryPath) > 0 {
|
|
page.WikiPath = pageType + "/" + strings.Join(categoryPath, "/") + "/" + page.Title
|
|
page.Depth = len(categoryPath)
|
|
}
|
|
return page
|
|
}
|
|
|
|
// TestList_WikiPathSortReturnsCategorizedPagesFirst protects the sidebar's
|
|
// IDE-like tree contract. Pagination happens in the repository, so the DB
|
|
// must return pages with category_path before loose root pages; otherwise the
|
|
// frontend cannot know about directories hiding on later pages.
|
|
func TestList_WikiPathSortReturnsCategorizedPagesFirst(t *testing.T) {
|
|
db := setupWikiPagesTestDB(t)
|
|
repo := NewWikiPageRepository(db)
|
|
ctx := context.Background()
|
|
|
|
pages := []*types.WikiPage{
|
|
makeWikiPage("kb-a", "entity/000-root", types.WikiPageTypeEntity, types.WikiPageStatusPublished),
|
|
makeCategorizedWikiPage("kb-a", "entity/999-child", types.WikiPageTypeEntity, types.WikiPageStatusPublished, "zzz-folder"),
|
|
makeWikiPage("kb-a", "entity/001-root", types.WikiPageTypeEntity, types.WikiPageStatusPublished),
|
|
}
|
|
for _, p := range pages {
|
|
require.NoError(t, repo.Create(ctx, p))
|
|
}
|
|
|
|
got, total, err := repo.List(ctx, &types.WikiPageListRequest{
|
|
KnowledgeBaseID: "kb-a",
|
|
PageType: types.WikiPageTypeEntity,
|
|
Page: 1,
|
|
PageSize: 10,
|
|
SortBy: "wiki_path",
|
|
SortOrder: "asc",
|
|
})
|
|
require.NoError(t, err)
|
|
assert.Equal(t, int64(3), total)
|
|
require.Len(t, got, 3)
|
|
assert.Equal(t, "entity/999-child", got[0].Slug)
|
|
assert.Equal(t, "entity/000-root", got[1].Slug)
|
|
assert.Equal(t, "entity/001-root", got[2].Slug)
|
|
}
|
|
|
|
// TestListByTypeLight_ProjectsNarrowColumnsAndExcludesArchived verifies
|
|
// that the index-view projection only emits the slug/title/summary
|
|
// triples and respects the archived-status filter. This is the whole
|
|
// point of splitting the method off ListByType — the index reader must
|
|
// not pay for TEXT content transport.
|
|
func TestListByTypeLight_ProjectsNarrowColumnsAndExcludesArchived(t *testing.T) {
|
|
db := setupWikiPagesTestDB(t)
|
|
repo := NewWikiPageRepository(db)
|
|
ctx := context.Background()
|
|
|
|
pages := []*types.WikiPage{
|
|
makeWikiPage("kb-a", "entity/alpha", types.WikiPageTypeEntity, types.WikiPageStatusPublished),
|
|
makeWikiPage("kb-a", "entity/beta", types.WikiPageTypeEntity, types.WikiPageStatusDraft),
|
|
makeWikiPage("kb-a", "entity/gamma", types.WikiPageTypeEntity, types.WikiPageStatusArchived),
|
|
makeWikiPage("kb-a", "concept/delta", types.WikiPageTypeConcept, types.WikiPageStatusPublished),
|
|
makeWikiPage("kb-other", "entity/leaked", types.WikiPageTypeEntity, types.WikiPageStatusPublished),
|
|
}
|
|
for _, p := range pages {
|
|
require.NoError(t, repo.Create(ctx, p))
|
|
}
|
|
|
|
entries, total, err := repo.ListByTypeLight(ctx, "kb-a", types.WikiPageTypeEntity, 50, 0)
|
|
require.NoError(t, err)
|
|
|
|
// Archived is excluded; sibling KB is excluded; everything else
|
|
// surfaces regardless of draft/published status (the index shows
|
|
// both so admins notice newly-drafted pages).
|
|
assert.Equal(t, int64(2), total)
|
|
require.Len(t, entries, 2)
|
|
|
|
// ORDER BY title ASC => alpha, beta.
|
|
assert.Equal(t, "entity/alpha", entries[0].Slug)
|
|
assert.Equal(t, "alpha", entries[0].Title)
|
|
assert.Equal(t, "summary of entity/alpha", entries[0].Summary)
|
|
assert.Equal(t, "entity/beta", entries[1].Slug)
|
|
}
|
|
|
|
// TestListByTypeLight_Pagination walks the type list using offsets and
|
|
// asserts the count stays stable regardless of where in the list we
|
|
// are — the index handler uses total to render "showing N of M".
|
|
func TestListByTypeLight_Pagination(t *testing.T) {
|
|
db := setupWikiPagesTestDB(t)
|
|
repo := NewWikiPageRepository(db)
|
|
ctx := context.Background()
|
|
|
|
for _, s := range []string{"entity/a", "entity/b", "entity/c", "entity/d", "entity/e"} {
|
|
require.NoError(t, repo.Create(ctx, makeWikiPage("kb-a", s, types.WikiPageTypeEntity, types.WikiPageStatusPublished)))
|
|
}
|
|
|
|
page1, total1, err := repo.ListByTypeLight(ctx, "kb-a", types.WikiPageTypeEntity, 2, 0)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, int64(5), total1)
|
|
require.Len(t, page1, 2)
|
|
assert.Equal(t, "entity/a", page1[0].Slug)
|
|
assert.Equal(t, "entity/b", page1[1].Slug)
|
|
|
|
page2, total2, err := repo.ListByTypeLight(ctx, "kb-a", types.WikiPageTypeEntity, 2, 2)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, int64(5), total2, "total should be stable across pages")
|
|
require.Len(t, page2, 2)
|
|
assert.Equal(t, "entity/c", page2[0].Slug)
|
|
assert.Equal(t, "entity/d", page2[1].Slug)
|
|
|
|
page3, total3, err := repo.ListByTypeLight(ctx, "kb-a", types.WikiPageTypeEntity, 2, 4)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, int64(5), total3)
|
|
require.Len(t, page3, 1)
|
|
assert.Equal(t, "entity/e", page3[0].Slug)
|
|
|
|
// Offset past the end yields an empty list, not an error — the
|
|
// handler relies on this to short-circuit pagination tails.
|
|
page4, total4, err := repo.ListByTypeLight(ctx, "kb-a", types.WikiPageTypeEntity, 2, 10)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, int64(5), total4)
|
|
assert.Empty(t, page4)
|
|
}
|
|
|
|
// TestListByTypeLight_EmptyType_ReturnsZero exercises the "no rows"
|
|
// short-circuit. We skip the SELECT entirely when count is zero, so
|
|
// a KB with no pages of a type shouldn't burn a pointless query.
|
|
func TestListByTypeLight_EmptyType_ReturnsZero(t *testing.T) {
|
|
db := setupWikiPagesTestDB(t)
|
|
repo := NewWikiPageRepository(db)
|
|
ctx := context.Background()
|
|
|
|
entries, total, err := repo.ListByTypeLight(ctx, "kb-empty", types.WikiPageTypeSynthesis, 50, 0)
|
|
require.NoError(t, err)
|
|
assert.Equal(t, int64(0), total)
|
|
assert.Empty(t, entries)
|
|
}
|
|
|
|
// TestListByTypeLight_ClampsLimit verifies the [1, 200] clamp. We don't
|
|
// want a client passing limit=100000 and forcing the DB to return a
|
|
// multi-MB response.
|
|
func TestListByTypeLight_ClampsLimit(t *testing.T) {
|
|
db := setupWikiPagesTestDB(t)
|
|
repo := NewWikiPageRepository(db)
|
|
ctx := context.Background()
|
|
|
|
for i := 0; i < 250; i++ {
|
|
slug := "entity/bulk-"
|
|
// Use a stable, zero-padded suffix so title ordering is
|
|
// deterministic for the cap assertion below.
|
|
slug += string(rune('a'+(i/26)%26)) + string(rune('a'+i%26))
|
|
require.NoError(t, repo.Create(ctx, makeWikiPage("kb-cap", slug, types.WikiPageTypeEntity, types.WikiPageStatusPublished)))
|
|
}
|
|
|
|
// limit=0 falls back to the default of 50.
|
|
defaultEntries, _, err := repo.ListByTypeLight(ctx, "kb-cap", types.WikiPageTypeEntity, 0, 0)
|
|
require.NoError(t, err)
|
|
assert.Len(t, defaultEntries, 50)
|
|
|
|
// limit=5000 clamps to 200.
|
|
clampedEntries, _, err := repo.ListByTypeLight(ctx, "kb-cap", types.WikiPageTypeEntity, 5000, 0)
|
|
require.NoError(t, err)
|
|
assert.LessOrEqual(t, len(clampedEntries), 200)
|
|
}
|