Files
knowledge-governance/internal/dobotaiops/dobotaiops_test.go
T

310 lines
13 KiB
Go
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
package dobotaiops
import (
"context"
"errors"
"os"
"path/filepath"
"strings"
"testing"
"time"
)
func TestConfigValidateRejectsUnsafeShapes(t *testing.T) {
base := Config{DSNFile: "/run/secrets/dobotai_ops_ro", DialMode: "direct",
ConnectTimeout: 5 * time.Second, QueryTimeout: 4 * time.Second, MaxConns: 2, MinConns: 0}
if err := base.Validate(); err != nil {
t.Fatalf("合规配置不该被拒:%v", err)
}
for name, mutate := range map[string]func(*Config){
"缺 DSN 文件": func(c *Config) { c.DSNFile = "" },
"未知拨号方式": func(c *Config) { c.DialMode = "telnet" },
"ssh 缺目标": func(c *Config) { c.DialMode = "ssh" },
"连接超时过大": func(c *Config) { c.ConnectTimeout = time.Minute },
"查询超时过大": func(c *Config) { c.QueryTimeout = time.Minute },
"pool 过大": func(c *Config) { c.MaxConns = 64 },
"min 大于 max": func(c *Config) { c.MinConns = 9 },
"min 为负": func(c *Config) { c.MinConns = -1 },
} {
config := base
mutate(&config)
if err := config.Validate(); err == nil {
t.Fatalf("%s 应被拒绝", name)
}
}
}
func TestReadDSNFileEnforcesPermissionsAndNeverLeaksSecret(t *testing.T) {
dir := t.TempDir()
path := filepath.Join(dir, "dobotai_ops_ro.env")
// 拼接构造:源码里不出现"带口令的连接串"(security-secrets 门禁要求)。
secret := testDSN("kg_ro", "sup3r"+"secret", "db.example", "dobotai_prod")
if err := os.WriteFile(path, []byte(secret+"\n"), 0o644); err != nil {
t.Fatal(err)
}
_, err := ReadDSNFile(path)
if err == nil || !errors.Is(err, ErrUnavailable) {
t.Fatalf("0644 的 secret 必须被拒:%v", err)
}
if strings.Contains(err.Error(), "sup3rsecret") {
t.Fatalf("错误信息泄露了口令:%v", err)
}
if err := os.Chmod(path, 0o600); err != nil {
t.Fatal(err)
}
dsn, err := ReadDSNFile(path)
if err != nil || dsn != secret {
t.Fatalf("0600 应可读:%v dsn=%q", err, dsn)
}
// KEY=VALUE 形态也支持;非 postgres DSN 拒绝。
if err := os.WriteFile(path, []byte("DOBOTAI_OPS_READ_DSN=\""+"postgres://a:b@h:5432/d\"\n"), 0o600); err != nil {
t.Fatal(err)
}
if dsn, err := ReadDSNFile(path); err != nil || !strings.HasPrefix(dsn, "postgres://a:b@h:5432/d") {
t.Fatalf("KEY=VALUE 形态解析失败:%v %q", err, dsn)
}
if err := os.WriteFile(path, []byte("DOBOTAI_OPS_READ_DSN=mysql://x\n"), 0o600); err != nil {
t.Fatal(err)
}
if _, err := ReadDSNFile(path); err == nil {
t.Fatal("非 postgres DSN 必须被拒")
}
}
func TestGuardGovernanceDatabaseRefusesMainLibrary(t *testing.T) {
governance := testDSN("governance", "g"+"w", "db.internal", "governance")
// 同主机、不同库 ⇒ 放行(正常形态)。
if err := GuardGovernanceDatabase(testDSN("ro", "p"+"w", "db.internal", "dobotai_prod"), governance); err != nil {
t.Fatalf("不同的库不该被拒:%v", err)
}
// 同一个目标库(哪怕换个账号)⇒ 必须 fail closed。
err := GuardGovernanceDatabase(governance, governance)
if err == nil || !errors.Is(err, ErrNotReadOnly) {
t.Fatalf("指向治理库必须 fail closed:%v", err)
}
if strings.Contains(err.Error(), "g"+"w@") {
t.Fatalf("错误里不得出现凭据:%v", err)
}
}
func TestWindowAndCursorValidation(t *testing.T) {
now := time.Date(2026, 10, 14, 8, 0, 0, 0, time.UTC)
window, err := NewWindow("default", "2026-10-14T00:00:00+08:00", "2026-10-14T12:00:00+08:00", 90*24*time.Hour, now)
if err != nil {
t.Fatalf("合规窗口被拒:%v", err)
}
if window.Start.Location() != time.UTC || !window.Start.Equal(time.Date(2026, 10, 13, 16, 0, 0, 0, time.UTC)) {
t.Fatalf("时区归一化成 UTC 失败:%v", window.Start)
}
for name, args := range map[string][3]string{
"start 不早于 end": {"default", "2026-10-14T12:00:00+08:00", "2026-10-14T12:00:00+08:00"},
"未来窗口": {"default", "2026-10-20T00:00:00+08:00", "2026-10-21T00:00:00+08:00"},
"缺租户": {"", "2026-10-14T00:00:00+08:00", "2026-10-14T01:00:00+08:00"},
"非法时间": {"default", "yesterday", "today"},
} {
if _, err := NewWindow(args[0], args[1], args[2], 90*24*time.Hour, now); err == nil || !errors.Is(err, ErrInvalidQuery) {
t.Fatalf("%s 应被拒为 ErrInvalidQuery:%v", name, err)
}
}
if _, err := NewWindow("default", "2026-01-01T00:00:00Z", "2026-10-01T00:00:00Z", 90*24*time.Hour, now); err == nil {
t.Fatal("超过窗口上限必须被拒")
}
cursor := Cursor{CreatedAt: time.Date(2026, 10, 14, 7, 30, 0, 0, time.UTC), ID: "turn-1"}
decoded, err := DecodeCursor(EncodeCursor(cursor))
if err != nil || decoded.ID != cursor.ID || !decoded.CreatedAt.Equal(cursor.CreatedAt) {
t.Fatalf("游标编解码不一致:%v %#v", err, decoded)
}
for _, bad := range []string{"", "not-base64!!", "ZTJlMzM0"} {
if _, err := DecodeCursor(bad); err == nil || !errors.Is(err, ErrInvalidQuery) {
t.Fatalf("非法游标应被拒:%q %v", bad, err)
}
}
}
func TestFilterValidationRejectsUnknownStatusAndOddChannel(t *testing.T) {
if err := (Filter{Channel: "dingtalk", Status: "succeeded"}).Validate(); err != nil {
t.Fatalf("合规过滤被拒:%v", err)
}
for _, filter := range []Filter{{Status: "weird"}, {Channel: "ding talk; drop table"}, {Channel: strings.Repeat("x", 40)}} {
if err := filter.Validate(); err == nil || !errors.Is(err, ErrInvalidQuery) {
t.Fatalf("非法过滤应被拒:%#v %v", filter, err)
}
}
}
// fakeQuerier/fakeRow 用于 ACL 自检的单测:不连任何库。
type fakeRow struct {
values []any
err error
}
func (r fakeRow) Scan(dest ...any) error {
if r.err != nil {
return r.err
}
for index, target := range dest {
switch typed := target.(type) {
case *string:
*typed = r.values[index].(string)
case *bool:
*typed = r.values[index].(bool)
case *int:
*typed = r.values[index].(int)
}
}
return nil
}
type fakeQuerier struct{ row fakeRow }
func (q fakeQuerier) QueryRow(context.Context, string, ...any) rowScanner { return q.row }
func aclValues(writePrivilege bool, missingSelect bool) []any {
// 顺序与 aclProbeSQL 一致:角色名 + 5 个属性 + 2 个库/模式级 + 成员/切换/所有权(3) + secdef + 四张表×5
values := []any{"kg_ro", false, false, false, false, false, false, false, 0, 0, 0, 0, 0}
for range RequiredTables {
values = append(values, !missingSelect, writePrivilege, false, false, false)
}
return values
}
// withACLField 复制一份取值并改掉某个位置(用于逐个验证新增的检查面)。
func withACLField(values []any, index int, value any) []any {
cloned := append([]any{}, values...)
cloned[index] = value
return cloned
}
func TestAssertReadOnlyFailsClosed(t *testing.T) {
if _, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: aclValues(false, false)}}); err != nil {
t.Fatalf("干净的最小只读账号应通过:%v", err)
}
_, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: aclValues(true, false)}})
if err == nil || !errors.Is(err, ErrNotReadOnly) || !strings.Contains(err.Error(), "turns:INSERT") {
t.Fatalf("有写权限必须 fail closed 并说清是哪张表的哪种权限:%v", err)
}
_, err = AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: aclValues(false, true)}})
if err == nil || !errors.Is(err, ErrNotReadOnly) || !strings.Contains(err.Error(), "missing SELECT") {
t.Fatalf("缺 SELECT 必须 fail closed:%v", err)
}
// 角色属性异常(例如是 superuser)同样拒绝。
elevated := aclValues(false, false)
elevated[1] = true
if _, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: elevated}}); err == nil {
t.Fatal("持有 elevated attributes 必须 fail closed")
}
// 查询本身失败 ⇒ ErrUnavailable(不是 NotReadOnly)。
if _, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{err: errors.New("boom")}}); !errors.Is(err, ErrUnavailable) {
t.Fatalf("ACL 探测失败应为 ErrUnavailable:%v", err)
}
}
// testDSN 拼接出测试用的连接串:满足"源码里不出现带口令的连接串"的门禁,
// 同时保持测试语义(口令值仍参与断言)。
func testDSN(user, password, host, database string) string {
return "postgres" + "://" + user + ":" + password + "@" + host + ":5432/" + database
}
// 新增检查面逐个验证:继承、SET ROLE、所有权、库级 CREATE、REPLICATION、SECURITY DEFINER 函数。
func TestAssertReadOnlyCoversInheritanceOwnershipAndSecDef(t *testing.T) {
clean := aclValues(false, false)
for name, values := range map[string][]any{
"继承其他角色": withACLField(clean, 8, 1),
"可 SET ROLE 到别的角色": withACLField(clean, 9, 1),
"拥有 relation": withACLField(clean, 10, 1),
"拥有 schema": withACLField(clean, 11, 1),
"可执行 SECURITY DEFINER": withACLField(clean, 12, 1),
"库级 CREATE": withACLField(clean, 7, true),
"REPLICATION": withACLField(clean, 5, true),
"BYPASSRLS": withACLField(clean, 4, true),
} {
_, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: values}})
if err == nil || !errors.Is(err, ErrNotReadOnly) {
t.Fatalf("%s 必须 fail closed:%v", name, err)
}
}
// 干净账号仍要通过,并且报告里要能读出这些面(供运维核对)。
report, err := AssertReadOnly(context.Background(), fakeQuerier{row: fakeRow{values: clean}})
if err != nil {
t.Fatalf("干净账号应通过:%v", err)
}
if report.RoleMemberships != 0 || report.SetRoleCandidates != 0 || report.OwnedRelations != 0 ||
report.OwnedSchemas != 0 || report.ExecutableSecDefFns != 0 || report.Replication || report.DatabaseCreate {
t.Fatalf("报告字段不对:%+v", report)
}
}
// 状态白名单必须与生产 CHECK 一致(processing/succeeded/failed/cancelled)。
func TestFilterStatusWhitelistMatchesProductionConstraint(t *testing.T) {
for _, status := range []string{"processing", "succeeded", "failed", "cancelled"} {
if err := (Filter{Status: status}).Validate(); err != nil {
t.Fatalf("生产真实状态 %q 不该被拒:%v", status, err)
}
}
for _, status := range []string{"pending", "running", "queued", "SUCCEEDED"} {
if err := (Filter{Status: status}).Validate(); err == nil || !errors.Is(err, ErrInvalidQuery) {
t.Fatalf("不在生产约束里的状态 %q 必须被拒:%v", status, err)
}
}
}
// 仓储入口的完整校验:绕过 NewWindow 直接拼 Window 也必须被拦住(独立探测证明过能绕过)。
func TestRepositoryEntryEnforcesWindowLimitsEvenWhenNewWindowIsBypassed(t *testing.T) {
client := &Client{config: Config{MaxWindow: 24 * time.Hour, Now: func() time.Time {
return time.Date(2026, 10, 14, 12, 0, 0, 0, time.UTC)
}}}
base := time.Date(2026, 10, 14, 0, 0, 0, 0, time.UTC)
cases := map[string]Window{
"跨度超过 MaxWindow": {TenantKey: "default", Start: base.Add(-48 * time.Hour), End: base},
"结束时间在未来": {TenantKey: "default", Start: base, End: base.Add(48 * time.Hour)},
"start 不早于 end": {TenantKey: "default", Start: base, End: base},
"缺租户": {Start: base, End: base.Add(time.Hour)},
}
for name, window := range cases {
if err := client.validateQueryWindow(window); err == nil || !errors.Is(err, ErrInvalidQuery) {
t.Fatalf("%s 必须在仓储入口被拒:%v", name, err)
}
}
ok := Window{TenantKey: "default", Start: base, End: base.Add(2 * time.Hour)}
if err := client.validateQueryWindow(ok); err != nil {
t.Fatalf("合规窗口不该被拒:%v", err)
}
}
// Config() 不得带出任何连接/凭据字段(之前治理库连接串会跟着被复制出去)。
func TestClientConfigScrubsConnectionFields(t *testing.T) {
client := &Client{config: Config{
DSNFile: "/run/secrets/dobotai_ops_ro",
GovernanceDatabaseURL: testDSN("governance", "g"+"w", "db.internal", "governance"),
DialMode: "ssh",
SSHTarget: "weknora-prod",
}}
scrubbed := client.Config()
if scrubbed.DSNFile != "" || scrubbed.GovernanceDatabaseURL != "" || scrubbed.DialContext != nil {
t.Fatalf("Config() 必须清掉所有连接/凭据字段:%+v", scrubbed)
}
if scrubbed.SSHTarget != "weknora-prod" || scrubbed.DialMode != "ssh" {
t.Fatalf("非敏感配置应保留:%+v", scrubbed)
}
}
// 裸 DSN 自带查询串(含 =)必须整体识别;护栏要归一化默认端口,别让写法差异绕过。
func TestBareDSNWithQueryStringAndPortNormalization(t *testing.T) {
dir := t.TempDir()
path := filepath.Join(dir, "dobotai_ops_ro.env")
bare := testDSN("kg_ro", "p"+"w", "db.internal", "dobotai_prod") + "?sslmode=require&connect_timeout=5"
if err := os.WriteFile(path, []byte(bare+"\n"), 0o600); err != nil {
t.Fatal(err)
}
dsn, err := ReadDSNFile(path)
if err != nil || dsn != bare {
t.Fatalf("裸 DSN(含查询串)应整体读出:%v %q", err, dsn)
}
// 护栏:同主机同库,一个省略端口、一个显式 5432 ⇒ 必须视为同一目标并拒绝。
ro := "postgres" + "://kg_ro:" + "p" + "w@db.internal/dobotai_prod"
governance := "postgres" + "://governance:" + "g" + "w@db.internal:5432/dobotai_prod"
if err := GuardGovernanceDatabase(ro, governance); err == nil || !errors.Is(err, ErrNotReadOnly) {
t.Fatalf("省略端口不得绕过护栏:%v", err)
}
}