开发检查点:收尾项目生命周期并接入资源读取隔离,待统一测试

This commit is contained in:
xuans committed 2026-09-28 21:20:20 +08:00
1 parent fd767b23c3
commit 709c1ef063
27 files changed
+785 -68

No files matched your search

@@ -66,8 +66,11 @@ func checkProjectDirectory(t *testing.T, cfg config.DatabaseConfig) {
if err != nil || page.Items == nil || len(page.Items) != tc.count || page.HasMore || page.NextCursor != "" {
t.Fatalf("项目可见性错误:%s,%+v,%v", tc.actor, page, err)
}
if page.CanCreateProject != (tc.actor == "root") {
t.Fatalf("空目录也必须返回正确创建能力:%s,%+v", tc.actor, page)
}
for _, item := range page.Items {
if page.CanCreateProject != (tc.actor == "root") || item.CanManageProject != tc.manage || item.CanDeleteProject != (tc.manage && item.ID != domain.DefaultProjectID) {
if item.CanManageProject != tc.manage || item.CanDeleteProject != (tc.manage && item.ID != domain.DefaultProjectID) {
t.Fatalf("生命周期能力错误:%s,%+v,%+v", tc.actor, page, item)
}
if item.CanManageMembers != tc.manage || (tc.actor != "root" && item.ID == domain.DefaultProjectID) {
@@ -0,0 +1,163 @@
package repository
import (
"context"
"database/sql"
"errors"
"fmt"
"strings"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
)
// ProjectResourceReader 将实时权限和资源读取合并,不向外部入口暴露全量基础仓储。
type ProjectResourceReader interface {
ListVisibleDomains(context.Context, string) ([]domain.Domain, error)
GetVisibleDomain(context.Context, string, string) (domain.Domain, error)
ListVisibleServers(context.Context, string) ([]deployment.Server, error)
GetVisibleServer(context.Context, string, string) (deployment.Server, error)
ListVisibleDomainServers(context.Context, string, string) ([]deployment.Server, error)
}
var _ ProjectResourceReader = (*SQLProjectMemberRepository)(nil)
const visibleDomainSelect = `SELECT domains.id, domains.name, domains.certificate_type,
domains.sans_json, domains.auto_renew, domains.acme_environment, domains.dns_provider,
domains.status, domains.expires_at, domains.created_at, domains.updated_at,
domains.project_id, domains.owner_id, domains.created_by, domains.updated_by FROM domains`
// 列名只接受内部固定值,角色能力复用领域模型;所有身份和角色值均使用绑定参数。
// EXISTS 避免多角色账户重复返回资源,不按用户分组或全局普通管理员身份放行。
func resourceReadPredicate(projectColumn, actorID string, permission domain.ProjectPermission) (string, []any) {
if projectColumn != "domains.project_id" && projectColumn != "servers.project_id" {
return "1 = 0", nil
}
if permission != domain.PermissionCertificateRead && permission != domain.PermissionServerRead {
return "1 = 0", nil
}
roles := []domain.ProjectRole{
domain.ProjectRoleAdmin, domain.ProjectRoleCertificateAdmin, domain.ProjectRoleDeploymentAdmin,
domain.ProjectRoleDNSAdmin, domain.ProjectRoleAuditViewer, domain.ProjectRoleReadOnly,
}
args := []any{actorID}
placeholders := make([]string, 0, len(roles))
for _, role := range roles {
if role.Allows(permission) {
placeholders = append(placeholders, "?")
args = append(args, string(role))
}
}
return `EXISTS (SELECT 1 FROM projects resource_project
JOIN users resource_actor ON resource_actor.id = ?
WHERE resource_project.id = ` + projectColumn + ` AND resource_actor.status = 'active'
AND (resource_actor.role = 'super_admin' OR (resource_actor.role IN ('admin', 'user')
AND EXISTS (SELECT 1 FROM project_members resource_member
WHERE resource_member.project_id = resource_project.id AND resource_member.user_id = resource_actor.id
AND resource_member.role IN (` + strings.Join(placeholders, ", ") + `)))))`, args
}
func (r *SQLProjectMemberRepository) resourceReaderReady(actorID string) error {
if err := r.ensureDB(); err != nil {
return err
}
if strings.TrimSpace(actorID) == "" || len(actorID) > 128 {
return ErrProjectAccessDenied
}
return nil
}
func (r *SQLProjectMemberRepository) ListVisibleDomains(ctx context.Context, actorID string) ([]domain.Domain, error) {
if err := r.resourceReaderReady(actorID); err != nil {
return nil, err
}
predicate, args := resourceReadPredicate("domains.project_id", actorID, domain.PermissionCertificateRead)
rows, err := r.db.QueryContext(ctx, Rebind(r.driver, visibleDomainSelect+` WHERE `+predicate+` ORDER BY domains.name, domains.id`), args...)
if err != nil {
return nil, fmt.Errorf("查询可见域名失败:%w", err)
}
defer rows.Close()
items := make([]domain.Domain, 0)
for rows.Next() {
item, err := scanDomain(rows)
if err != nil {
return nil, err
}
items = append(items, item)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("读取可见域名失败:%w", err)
}
return items, nil
}
func (r *SQLProjectMemberRepository) GetVisibleDomain(ctx context.Context, actorID, id string) (domain.Domain, error) {
if err := r.resourceReaderReady(actorID); err != nil {
return domain.Domain{}, err
}
predicate, args := resourceReadPredicate("domains.project_id", actorID, domain.PermissionCertificateRead)
args = append(args, id)
item, err := scanDomain(r.db.QueryRowContext(ctx, Rebind(r.driver,
visibleDomainSelect+` WHERE `+predicate+` AND domains.id = ?`), args...))
if errors.Is(err, sql.ErrNoRows) {
return domain.Domain{}, ErrProjectAccessDenied
}
return item, err
}
func (r *SQLProjectMemberRepository) ListVisibleServers(ctx context.Context, actorID string) ([]deployment.Server, error) {
if err := r.resourceReaderReady(actorID); err != nil {
return nil, err
}
predicate, args := resourceReadPredicate("servers.project_id", actorID, domain.PermissionServerRead)
return r.readVisibleServers(ctx, serverSelectQualified+` WHERE `+predicate+` ORDER BY servers.name, servers.id`, args)
}
func (r *SQLProjectMemberRepository) GetVisibleServer(ctx context.Context, actorID, id string) (deployment.Server, error) {
if err := r.resourceReaderReady(actorID); err != nil {
return deployment.Server{}, err
}
predicate, args := resourceReadPredicate("servers.project_id", actorID, domain.PermissionServerRead)
args = append(args, id)
item, err := scanServer(r.db.QueryRowContext(ctx, Rebind(r.driver,
serverSelectQualified+` WHERE `+predicate+` AND servers.id = ?`), args...))
if errors.Is(err, sql.ErrNoRows) {
return deployment.Server{}, ErrProjectAccessDenied
}
return item, err
}
func (r *SQLProjectMemberRepository) ListVisibleDomainServers(ctx context.Context, actorID, domainID string) ([]deployment.Server, error) {
// 对未知和无权限域名统一拒绝;随后的查询仍重判双方权限,撤权后不会返回旧结果。
if _, err := r.GetVisibleDomain(ctx, actorID, domainID); err != nil {
return nil, err
}
domainPredicate, args := resourceReadPredicate("domains.project_id", actorID, domain.PermissionCertificateRead)
serverPredicate, serverArgs := resourceReadPredicate("servers.project_id", actorID, domain.PermissionServerRead)
args = append(args, serverArgs...)
args = append(args, domainID)
return r.readVisibleServers(ctx, serverSelectQualified+`
JOIN domain_servers visible_binding ON visible_binding.server_id = servers.id
JOIN domains ON domains.id = visible_binding.domain_id AND domains.project_id = servers.project_id
WHERE `+domainPredicate+` AND `+serverPredicate+` AND domains.id = ? ORDER BY servers.name, servers.id`, args)
}
func (r *SQLProjectMemberRepository) readVisibleServers(ctx context.Context, query string, args []any) ([]deployment.Server, error) {
rows, err := r.db.QueryContext(ctx, Rebind(r.driver, query), args...)
if err != nil {
return nil, fmt.Errorf("查询可见服务器失败:%w", err)
}
defer rows.Close()
items := make([]deployment.Server, 0)
for rows.Next() {
item, err := scanServer(rows)
if err != nil {
return nil, err
}
items = append(items, item)
}
if err := rows.Err(); err != nil {
return nil, fmt.Errorf("读取可见服务器失败:%w", err)
}
return items, nil
}
@@ -0,0 +1,165 @@
package repository
import (
"context"
"errors"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/database"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/testsupport/mysqltest"
)
func TestProjectResourcesSQLite(t *testing.T) {
checkProjectResources(t, config.Default(t.TempDir()).Database)
}
func TestProjectResourcesMySQLReal(t *testing.T) {
server := mysqltest.New(t)
checkProjectResources(t, server.Database(t))
}
func checkProjectResources(t *testing.T, cfg config.DatabaseConfig) {
t.Helper()
db, err := database.Open(t.Context(), cfg)
if err != nil {
t.Fatal(err)
}
t.Cleanup(func() { _ = db.Close() })
if err := database.Migrate(t.Context(), db.DB, cfg.Driver); err != nil {
t.Fatal(err)
}
repo := NewSQLProjectMemberRepository(db.DB, cfg.Driver)
projects := NewSQLProjectRepository(db.DB, cfg.Driver)
domains := NewSQLDomainRepository(db.DB, cfg.Driver)
servers := NewSQLServerRepository(db.DB, cfg.Driver)
for _, user := range []struct{ id, role string }{
{"root", "super_admin"}, {"manager", "user"}, {"cert", "user"}, {"deploy", "admin"},
{"dns", "user"}, {"audit", "user"}, {"reader", "user"}, {"outsider", "admin"},
} {
if _, err := db.DB.ExecContext(t.Context(), Rebind(cfg.Driver, `INSERT INTO users
(id, username, password_hash, role, status) VALUES (?, ?, 'test-only-no-login', ?, 'active')`),
user.id, user.id, user.role); err != nil {
t.Fatal(err)
}
}
for _, id := range []string{"a", "b"} {
if err := projects.CreateProject(t.Context(), domain.Project{ID: "project-" + id, Name: "资源项目"}); err != nil {
t.Fatal(err)
}
item, err := domain.NewDomain(id+".example.test", domain.CertificateSingle, nil)
if err != nil {
t.Fatal(err)
}
item.ID, item.ProjectID = "domain-"+id, "project-"+id
if err := domains.Create(t.Context(), item); err != nil {
t.Fatal(err)
}
server := deployment.Server{
ResourceScope: domain.ResourceScope{ProjectID: item.ProjectID},
ID: "server-" + id, Name: "资源服务器", Address: "192.0.2.10", Port: 22, Username: "deploy",
PrivateKeyRef: "secret://ssh/fixture", HostKeyFingerprint: "SHA256:test",
CertificatePath: "/ssl/cert.pem", PrivateKeyPath: "/ssl/key.pem", WebServer: deployment.WebServerNginx,
}
if err := servers.CreateServer(t.Context(), server); err != nil {
t.Fatal(err)
}
if err := servers.ReplaceDomainServers(t.Context(), item.ID, []string{server.ID}); err != nil {
t.Fatal(err)
}
}
for actor, role := range map[string]domain.ProjectRole{
"manager": domain.ProjectRoleAdmin, "cert": domain.ProjectRoleCertificateAdmin,
"deploy": domain.ProjectRoleDeploymentAdmin, "dns": domain.ProjectRoleDNSAdmin,
"audit": domain.ProjectRoleAuditViewer, "reader": domain.ProjectRoleReadOnly,
} {
if err := repo.GrantProjectRole(t.Context(), "root", "project-a", actor, role); err != nil {
t.Fatal(err)
}
}
if err := repo.GrantProjectRole(t.Context(), "root", "project-a", "manager", domain.ProjectRoleReadOnly); err != nil {
t.Fatal(err)
}
t.Run("lists_filter_and_deduplicate", func(t *testing.T) {
for _, tc := range []struct {
actor string
domains, servers int
}{
{"root", 2, 2}, {"manager", 1, 1}, {"cert", 1, 0}, {"deploy", 1, 1},
{"dns", 0, 0}, {"audit", 0, 0}, {"reader", 1, 1}, {"outsider", 0, 0}, {"missing", 0, 0},
} {
domainItems, err := repo.ListVisibleDomains(t.Context(), tc.actor)
if err != nil || domainItems == nil || len(domainItems) != tc.domains {
t.Fatalf("域名范围错误:%s,%+v,%v", tc.actor, domainItems, err)
}
serverItems, err := repo.ListVisibleServers(t.Context(), tc.actor)
if err != nil || serverItems == nil || len(serverItems) != tc.servers {
t.Fatalf("服务器范围错误:%s,%+v,%v", tc.actor, serverItems, err)
}
if tc.actor != "root" {
for _, item := range domainItems {
if item.ProjectID != "project-a" {
t.Fatalf("跨项目域名泄露:%+v", item)
}
}
for _, item := range serverItems {
if item.ProjectID != "project-a" {
t.Fatalf("跨项目服务器泄露:%+v", item)
}
}
}
}
})
t.Run("details_and_bindings_use_real_scope", func(t *testing.T) {
for _, id := range []string{"b", "missing", "a' OR 1=1 --"} {
if _, err := repo.GetVisibleDomain(t.Context(), "reader", "domain-"+id); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatalf("越权域名应统一拒绝:%s,%v", id, err)
}
if _, err := repo.GetVisibleServer(t.Context(), "reader", "server-"+id); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatalf("越权服务器应统一拒绝:%s,%v", id, err)
}
}
for _, actor := range []string{"root", "manager", "reader", "cert"} {
items, err := repo.ListVisibleDomainServers(t.Context(), actor, "domain-a")
want := 1
if actor == "cert" {
want = 0
}
if err != nil || len(items) != want || (want == 1 && items[0].ID != "server-a") {
t.Fatalf("绑定未核对双方读取权限:%s,%+v,%v", actor, items, err)
}
}
if _, err := repo.ListVisibleDomainServers(t.Context(), "reader", "domain-b"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatalf("越权绑定查询未拒绝:%v", err)
}
})
t.Run("revocation_and_disabled_account_are_not_cached", func(t *testing.T) {
if err := repo.RevokeProjectRole(t.Context(), "root", "project-a", "reader", domain.ProjectRoleReadOnly); err != nil {
t.Fatal(err)
}
if _, err := repo.GetVisibleDomain(t.Context(), "reader", "domain-a"); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatalf("撤权后仍能读取:%v", err)
}
if _, err := db.DB.ExecContext(t.Context(), `UPDATE users SET status = 'disabled' WHERE id = 'manager'`); err != nil {
t.Fatal(err)
}
for _, actor := range []string{"reader", "manager"} {
items, err := repo.ListVisibleServers(t.Context(), actor)
if err != nil || len(items) != 0 {
t.Fatalf("撤权或停用后仍有资源:%s,%+v,%v", actor, items, err)
}
}
})
t.Run("canceled_and_missing_identity", func(t *testing.T) {
ctx, cancel := context.WithCancel(t.Context())
cancel()
if _, err := repo.ListVisibleDomains(ctx, "root"); err == nil {
t.Fatal("取消请求不应成功")
}
if _, err := repo.ListVisibleServers(t.Context(), ""); !errors.Is(err, ErrProjectAccessDenied) {
t.Fatalf("空身份未拒绝:%v", err)
}
})
}