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

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

@@ -57,7 +57,8 @@ func TestAuthSessionsSupportOptionalEmail(t *testing.T) {
if !payload.Authenticated || payload.Email != "" || payload.Role != role || payload.IsAdmin != (role == repository.UserRoleAdmin) {
t.Fatalf("unexpected session identity: %+v", payload)
}
request := httptest.NewRequest(http.MethodGet, "/api/v1/domains", nil)
// 全局管理角色边界使用系统设置;域名读取现按项目成员身份判定。
request := httptest.NewRequest(http.MethodGet, "/api/v1/settings", nil)
request.AddCookie(cookies[0])
access := httptest.NewRecorder()
server.Handler().ServeHTTP(access, request)
+12 -3
View File
@@ -30,13 +30,16 @@ type certificatePathRequest struct {
}
func (s *Server) listCertificates(c *gin.Context) {
if s.repository == nil || s.currentCertificate == nil {
if !s.requireProjectResourceReader(c) {
return
}
if s.currentCertificate == nil {
s.writeError(c, http.StatusNotImplemented, "证书管理接口尚未配置", errors.New("证书服务未配置"))
return
}
items, err := s.repository.List(c.Request.Context())
items, err := s.projectResources.ListVisibleDomains(c.Request.Context(), c.GetString(authenticatedActorKey))
if err != nil {
s.writeError(c, http.StatusInternalServerError, "查询域名证书失败", err)
s.writeProjectResourceError(c, err)
return
}
result := make([]gin.H, 0, len(items))
@@ -57,6 +60,9 @@ func (s *Server) listCertificates(c *gin.Context) {
}
func (s *Server) getCertificate(c *gin.Context) {
if !s.requireVisibleCertificateDomain(c) {
return
}
if s.currentCertificate == nil {
s.writeError(c, http.StatusNotImplemented, "证书管理接口尚未配置", errors.New("证书服务未配置"))
return
@@ -70,6 +76,9 @@ func (s *Server) getCertificate(c *gin.Context) {
}
func (s *Server) listCertificateVersions(c *gin.Context) {
if !s.requireVisibleCertificateDomain(c) {
return
}
if s.currentCertificate == nil {
s.writeError(c, http.StatusNotImplemented, "证书管理接口尚未配置", errors.New("证书服务未配置"))
return
@@ -49,7 +49,11 @@ func TestCertificateReadAPIs(t *testing.T) {
versions: []certificate.SavedResource{{Version: "20260827-120000.000000000"}},
}
repo := &stubDomainRepository{items: []domain.Domain{{ID: "domain-1", Name: "example.com", CertificateType: domain.CertificateSAN}}}
server := New(Dependencies{Config: readyTestConfig(t.TempDir()), Repository: repo, CurrentCertificate: reader})
repo.loaded = repo.items[0]
server := New(Dependencies{
Config: readyTestConfig(t.TempDir()), Repository: repo, CurrentCertificate: reader,
ProjectResources: projectResourceReaderStub{domains: repo},
})
list := httptest.NewRecorder()
serveAdminHTTP(server, list, httptest.NewRequest(http.MethodGet, "/api/v1/certificates", nil))
@@ -79,6 +83,7 @@ func TestCertificateListHidesReaderErrors(t *testing.T) {
Config: readyTestConfig(t.TempDir()),
Repository: repo,
CurrentCertificate: reader,
ProjectResources: projectResourceReaderStub{domains: repo},
})
response := httptest.NewRecorder()
+3 -3
View File
@@ -77,7 +77,7 @@ func TestAdminAPIAcceptsAuthenticatedSessionAndRejectsCrossOrigin(t *testing.T)
t.Fatal("登录响应未返回会话 Cookie")
}
authenticatedRequest := httptest.NewRequest(http.MethodGet, "/api/v1/domains", nil)
authenticatedRequest := httptest.NewRequest(http.MethodGet, "/api/v1/settings", nil)
authenticatedRequest.AddCookie(cookie[0])
authenticatedResponse := httptest.NewRecorder()
server.Handler().ServeHTTP(authenticatedResponse, authenticatedRequest)
@@ -85,7 +85,7 @@ func TestAdminAPIAcceptsAuthenticatedSessionAndRejectsCrossOrigin(t *testing.T)
t.Fatalf("登录后访问管理接口失败:%d %s", authenticatedResponse.Code, authenticatedResponse.Body.String())
}
crossOriginRequest := httptest.NewRequest(http.MethodGet, "/api/v1/domains", nil)
crossOriginRequest := httptest.NewRequest(http.MethodGet, "/api/v1/settings", nil)
crossOriginRequest.AddCookie(cookie[0])
crossOriginRequest.Host = "127.0.0.1:5200"
crossOriginRequest.Header.Set("Origin", "https://malicious.example")
@@ -108,7 +108,7 @@ func TestAdminAPIRejectsAuthenticatedRegularUser(t *testing.T) {
cfg.Admin.PasswordHash = string(hash)
server := New(Dependencies{Config: cfg, Repository: &stubDomainRepository{}})
cookie := httpUserSessionCookie(server, "user-1", repository.UserRoleUser)
response := serveUserRequest(server, cookie, http.MethodGet, "/api/v1/domains", "")
response := serveUserRequest(server, cookie, http.MethodGet, "/api/v1/settings", "")
if response.Code != http.StatusForbidden {
t.Fatalf("普通用户访问管理接口应返回 403,实际为 %d:%s", response.Code, response.Body.String())
}
@@ -24,7 +24,7 @@ func (s *Server) projectLifecycleReady(c *gin.Context, creating bool) bool {
s.writeError(c, http.StatusServiceUnavailable, "项目管理服务尚未就绪", nil)
return false
}
if c.Request.URL.RawQuery != "" || (!creating && !validMemberIdentifier(c.Param("projectID"))) {
if c.Request.URL.RawQuery != "" || (!creating && !domain.ValidProjectID(c.Param("projectID"))) {
s.writeError(c, http.StatusBadRequest, "项目请求参数无效", nil)
return false
}
@@ -119,7 +119,7 @@ func (s *Server) projectFailureAudit(action string) gin.HandlerFunc {
return
}
projectID := c.Param("projectID")
if !validMemberIdentifier(projectID) {
if !domain.ValidProjectID(projectID) {
projectID = ""
}
ctx, cancel := context.WithTimeout(context.WithoutCancel(c.Request.Context()), 3*time.Second)
@@ -27,7 +27,7 @@ func (s *Server) projectMemberRequestReady(c *gin.Context) bool {
s.writeError(c, http.StatusServiceUnavailable, "项目成员服务尚未就绪", nil)
return false
}
if !validMemberIdentifier(c.Param("projectID")) {
if !domain.ValidProjectID(c.Param("projectID")) {
s.writeError(c, http.StatusBadRequest, "项目标识无效", nil)
return false
}
@@ -6,6 +6,7 @@ import (
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
@@ -17,7 +18,7 @@ func (s *Server) projectMemberFailureAudit(action string) gin.HandlerFunc {
return
}
projectID := c.Param("projectID")
if !validMemberIdentifier(projectID) {
if !domain.ValidProjectID(projectID) {
projectID = ""
}
target := c.GetString(projectMemberTargetKey)
@@ -48,7 +48,10 @@ func newProjectMemberAPIFixture(t *testing.T) projectMemberAPIFixture {
db: db.DB, members: repository.NewSQLProjectMemberRepository(db.DB, cfg.Database.Driver),
audit: repository.NewSQLAuditRepository(db.DB, cfg.Database.Driver), cookies: make(map[string]*http.Cookie),
}
f.server = New(Dependencies{Config: cfg, Users: users, ProjectMembers: f.members, ProjectDirectory: f.members, ProjectLifecycle: f.members, Audit: f.audit})
f.server = New(Dependencies{
Config: cfg, Users: users, ProjectMembers: f.members, ProjectDirectory: f.members,
ProjectLifecycle: f.members, ProjectResources: f.members, Audit: f.audit,
})
for _, account := range []struct{ id, role string }{
{"primary-super-admin", repository.UserRoleSuperAdmin}, {"manager", repository.UserRoleUser},
{"global-admin", repository.UserRoleAdmin}, {"viewer", repository.UserRoleUser}, {"target", repository.UserRoleUser},
@@ -0,0 +1,49 @@
package httpapi
import (
"errors"
"net/http"
"github.com/gin-gonic/gin"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
func (s *Server) registerProjectResourceRoutes() {
api := s.router.Group("/api/v1", privateProjectResponse, s.requireAuthenticated)
api.GET("/domains", s.listDomains)
api.GET("/servers", s.listServers)
api.GET("/servers/:id", s.getServer)
api.GET("/domains/:id/servers", s.listDomainServers)
api.GET("/certificates", s.listCertificates)
api.GET("/certificates/:id", s.getCertificate)
api.GET("/domains/:id/certificate/versions", s.listCertificateVersions)
}
func (s *Server) requireProjectResourceReader(c *gin.Context) bool {
if s.projectResources == nil {
s.writeError(c, http.StatusServiceUnavailable, "项目资源服务尚未就绪", nil)
return false
}
return true
}
func (s *Server) writeProjectResourceError(c *gin.Context, err error) {
if errors.Is(err, repository.ErrProjectAccessDenied) {
// 无权限和不存在使用相同响应,不泄露其他项目的资源是否存在。
s.writeError(c, http.StatusForbidden, "无权读取此项目资源", nil)
return
}
s.writeError(c, http.StatusInternalServerError, "读取项目资源失败,请稍后重试", nil)
}
func (s *Server) requireVisibleCertificateDomain(c *gin.Context) bool {
if !s.requireProjectResourceReader(c) {
return false
}
if _, err := s.projectResources.GetVisibleDomain(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("id")); err != nil {
s.writeProjectResourceError(c, err)
return false
}
return true
}
@@ -0,0 +1,190 @@
package httpapi
import (
"context"
"encoding/json"
"net/http"
"net/http/httptest"
"strings"
"testing"
"git.pcux.cn/xuans/Scert/backend/internal/certificate"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
type resourceCertificateReader struct {
reads []string
}
func (r *resourceCertificateReader) Current(_ context.Context, id string) (certificate.IssueResult, error) {
r.reads = append(r.reads, id)
return certificate.IssueResult{DomainID: id}, nil
}
func (r *resourceCertificateReader) ListVersions(_ context.Context, id string) ([]certificate.SavedResource, error) {
r.reads = append(r.reads, id)
return []certificate.SavedResource{}, nil
}
func newProjectResourceAPIFixture(t *testing.T) (projectMemberAPIFixture, *resourceCertificateReader) {
t.Helper()
f := newProjectMemberAPIFixture(t)
domains := repository.NewSQLDomainRepository(f.db)
servers := repository.NewSQLServerRepository(f.db)
for _, suffix := range []string{"a", "b"} {
item, err := domain.NewDomain(suffix+".example.test", domain.CertificateSingle, nil)
if err != nil {
t.Fatal(err)
}
item.ID, item.ProjectID = "domain-"+suffix, "project-"+suffix
if err := domains.Create(t.Context(), item); err != nil {
t.Fatal(err)
}
server := deployment.Server{
ResourceScope: domain.ResourceScope{ProjectID: item.ProjectID},
ID: "server-" + suffix, Name: suffix + " 服务器", 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)
}
}
reader := &resourceCertificateReader{}
f.server.repository, f.server.servers, f.server.currentCertificate = domains, servers, reader
return f, reader
}
func TestProjectResourceAPIListsUseProjectPermissions(t *testing.T) {
f, reader := newProjectResourceAPIFixture(t)
for _, tc := range []struct {
actor string
count int
}{
{"primary-super-admin", 2}, {"manager", 1}, {"viewer", 1}, {"global-admin", 0}, {"target", 0},
} {
for _, path := range []string{"/api/v1/domains", "/api/v1/servers", "/api/v1/certificates"} {
reader.reads = nil
response := serveUserRequest(f.server, f.cookies[tc.actor], http.MethodGet, path, "")
var page struct {
Items []json.RawMessage `json:"items"`
}
if response.Code != http.StatusOK || json.Unmarshal(response.Body.Bytes(), &page) != nil || page.Items == nil || len(page.Items) != tc.count {
t.Fatalf("可见资源范围错误:%s,%s,%d,%s", tc.actor, path, response.Code, response.Body.String())
}
if response.Header().Get("Cache-Control") != "private, no-store" || !strings.Contains(response.Header().Get("Vary"), "Cookie") {
t.Fatalf("资源响应缺少身份缓存隔离:%v", response.Header())
}
if tc.actor != "primary-super-admin" && strings.Contains(response.Body.String(), "project-b") {
t.Fatalf("泄露其他项目:%s", response.Body.String())
}
if path == "/api/v1/certificates" && len(reader.reads) != tc.count {
t.Fatalf("证书读取器访问了无权限域名:%+v", reader.reads)
}
}
}
}
func TestProjectResourceAPIDetailsHideExistenceAndGateFiles(t *testing.T) {
f, reader := newProjectResourceAPIFixture(t)
for _, suffix := range []string{"a", "b", "missing"} {
for _, path := range []string{
"/api/v1/servers/server-" + suffix,
"/api/v1/certificates/domain-" + suffix,
"/api/v1/domains/domain-" + suffix + "/certificate/versions",
"/api/v1/domains/domain-" + suffix + "/servers",
} {
reader.reads = nil
response := serveUserRequest(f.server, f.cookies["viewer"], http.MethodGet, path, "")
want := http.StatusForbidden
if suffix == "a" {
want = http.StatusOK
}
if response.Code != want {
t.Fatalf("资源详情权限错误:%s,%d,%s", path, response.Code, response.Body.String())
}
if suffix != "a" && (len(reader.reads) != 0 || !strings.Contains(response.Body.String(), "无权读取此项目资源")) {
t.Fatalf("拒绝前访问了证书文件或泄露资源:%s,%+v", response.Body.String(), reader.reads)
}
}
}
}
type resourceReadBoundary struct {
repository.ProjectResourceReader
before func()
}
func (r resourceReadBoundary) ListVisibleDomains(ctx context.Context, actor string) ([]domain.Domain, error) {
r.before()
return r.ProjectResourceReader.ListVisibleDomains(ctx, actor)
}
func TestProjectResourceAPIRechecksAfterSessionValidation(t *testing.T) {
for _, mode := range []string{"revoke", "disable"} {
t.Run(mode, func(t *testing.T) {
f, reader := newProjectResourceAPIFixture(t)
f.server.projectResources = resourceReadBoundary{ProjectResourceReader: f.members, before: func() {
if mode == "revoke" {
if err := f.members.RevokeProjectRole(t.Context(), "primary-super-admin", "project-a", "viewer", domain.ProjectRoleReadOnly); err != nil {
t.Fatal(err)
}
} else if _, err := f.db.ExecContext(t.Context(), `UPDATE users SET status = 'disabled' WHERE id = 'viewer'`); err != nil {
t.Fatal(err)
}
}}
response := serveUserRequest(f.server, f.cookies["viewer"], http.MethodGet, "/api/v1/certificates", "")
if response.Code != http.StatusOK || len(reader.reads) != 0 || !strings.Contains(response.Body.String(), `"items":[]`) {
t.Fatalf("会话通过后撤权仍读取资源:%d,%s,%+v", response.Code, response.Body.String(), reader.reads)
}
})
}
}
func TestProjectResourceAPIMissingDependencyFailsClosed(t *testing.T) {
f, reader := newProjectResourceAPIFixture(t)
f.server.projectResources = nil
for _, path := range []string{
"/api/v1/domains", "/api/v1/servers", "/api/v1/servers/server-a", "/api/v1/certificates",
"/api/v1/certificates/domain-a", "/api/v1/domains/domain-a/certificate/versions", "/api/v1/domains/domain-a/servers",
} {
response := serveUserRequest(f.server, f.cookies["primary-super-admin"], http.MethodGet, path, "")
if response.Code != http.StatusServiceUnavailable || len(reader.reads) != 0 {
t.Fatalf("缺失授权依赖时不应回退全量仓储:%s,%d,%s", path, response.Code, response.Body.String())
}
}
}
func TestProjectResourceAPIAuthenticationAndScopeForgery(t *testing.T) {
f, reader := newProjectResourceAPIFixture(t)
for _, path := range []string{"/api/v1/domains", "/api/v1/servers", "/api/v1/certificates"} {
request := httptest.NewRequest(http.MethodGet, path, nil)
response := httptest.NewRecorder()
f.server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusUnauthorized || response.Header().Get("Cache-Control") != "private, no-store" {
t.Fatalf("未认证读取未拒绝或缺少缓存保护:%s,%d", path, response.Code)
}
request = httptest.NewRequest(http.MethodGet, path, nil)
request.AddCookie(f.cookies["viewer"])
request.Header.Set("Origin", "https://foreign.example.test")
response = httptest.NewRecorder()
f.server.Handler().ServeHTTP(response, request)
if response.Code != http.StatusForbidden {
t.Fatalf("跨来源读取未拒绝:%s,%d", path, response.Code)
}
}
for _, path := range []string{
"/api/v1/servers/server-b?project_id=project-a&actor_id=primary-super-admin",
"/api/v1/certificates/domain-b?project_id=project-a&actor_id=primary-super-admin",
} {
response := serveUserRequest(f.server, f.cookies["viewer"], http.MethodGet, path, "")
if response.Code != http.StatusForbidden || len(reader.reads) != 0 {
t.Fatalf("客户端伪造身份或项目生效:%s,%d", path, response.Code)
}
}
}
+1 -1
View File
@@ -118,7 +118,7 @@ func TestHTTPServerUsesProductionTimeoutsAndTLSMinimum(t *testing.T) {
func TestDomainAPIValidatesSANAndHidesInternalErrors(t *testing.T) {
cfg := readyTestConfig(t.TempDir())
repo := &stubDomainRepository{}
server := New(Dependencies{Config: cfg, Repository: repo})
server := New(Dependencies{Config: cfg, Repository: repo, ProjectResources: projectResourceReaderStub{domains: repo}})
invalid := httptest.NewRequest(http.MethodPost, "/api/v1/domains", strings.NewReader(`{"name":"example.com","certificate_type":"san","sans":["bad_domain"]}`))
invalid.Header.Set("Content-Type", "application/json")
+16 -37
View File
@@ -51,6 +51,7 @@ type Dependencies struct {
ProjectMembers repository.ProjectMemberRepository
ProjectDirectory repository.ProjectDirectoryRepository
ProjectLifecycle repository.ProjectLifecycleRepository
ProjectResources repository.ProjectResourceReader
SSHKeys *sshkey.Service
DeploymentFactory deployment.ClientFactory
SetupDNS setupDNSVerifier
@@ -85,6 +86,7 @@ type Server struct {
projectMembers repository.ProjectMemberRepository
projectDirectory repository.ProjectDirectoryRepository
projectLifecycle repository.ProjectLifecycleRepository
projectResources repository.ProjectResourceReader
sshKeys *sshkey.Service
deploymentFactory deployment.ClientFactory
setupDNS setupDNSVerifier
@@ -148,6 +150,7 @@ func New(deps Dependencies) *Server {
projectMembers: deps.ProjectMembers,
projectDirectory: deps.ProjectDirectory,
projectLifecycle: deps.ProjectLifecycle,
projectResources: deps.ProjectResources,
sshKeys: deps.SSHKeys,
deploymentFactory: deps.DeploymentFactory,
issueCertificate: deps.IssueCertificate,
@@ -197,8 +200,8 @@ func (s *Server) registerRoutes() {
userAPI.DELETE("/:id", s.requireSuperAdmin, s.deleteUser)
s.registerProjectMemberRoutes()
s.registerProjectLifecycleRoutes()
s.registerProjectResourceRoutes()
s.router.GET("/api/v1/projects", privateProjectResponse, s.requireAuthenticated, s.listVisibleProjects)
adminAPI.GET("/domains", s.listDomains)
adminAPI.POST("/domains", s.dnsOperation, s.createDomain)
adminAPI.PUT("/domains/:id", s.dnsOperation, s.updateDomain)
adminAPI.DELETE("/domains/:id", s.deleteDomain)
@@ -215,18 +218,12 @@ func (s *Server) registerRoutes() {
adminAPI.POST("/dns/test", s.dnsOperation, s.testAdminDNS)
adminAPI.POST("/dns/aliyun/check", s.dnsOperation, s.checkAliyunDNSDomain)
adminAPI.POST("/renewal/run", s.longOperation(certificateTaskTimeout), s.runRenewalNow)
adminAPI.GET("/certificates", s.listCertificates)
adminAPI.GET("/certificates/:id", s.getCertificate)
adminAPI.POST("/domains/:id/certificate/import", s.longOperation(certificateTaskTimeout), s.importCertificateFiles)
adminAPI.POST("/domains/:id/certificate/validate", s.longOperation(certificateTaskTimeout), s.validateCertificate)
adminAPI.POST("/domains/:id/deploy", s.longOperation(certificateTaskTimeout), s.deployCertificateCurrent)
adminAPI.GET("/domains/:id/certificate/versions", s.listCertificateVersions)
adminAPI.POST("/domains/:id/certificate/versions/:version/restore", s.longOperation(certificateTaskTimeout), s.restoreCertificateVersion)
adminAPI.GET("/domains/:id/servers", s.listDomainServers)
adminAPI.PUT("/domains/:id/servers", s.replaceDomainServers)
adminAPI.GET("/servers", s.listServers)
adminAPI.POST("/servers", s.createServer)
adminAPI.GET("/servers/:id", s.getServer)
adminAPI.PUT("/servers/:id", s.updateServer)
adminAPI.DELETE("/servers/:id", s.deleteServer)
adminAPI.GET("/ssh-keys", s.listSSHKeys)
@@ -529,12 +526,12 @@ func (s *Server) requireDomainRepository(c *gin.Context) bool {
}
func (s *Server) listDomains(c *gin.Context) {
if !s.requireDomainRepository(c) {
if !s.requireProjectResourceReader(c) {
return
}
items, err := s.repository.List(c.Request.Context())
items, err := s.projectResources.ListVisibleDomains(c.Request.Context(), c.GetString(authenticatedActorKey))
if err != nil {
s.writeError(c, http.StatusInternalServerError, "查询域名失败", err)
s.writeProjectResourceError(c, err)
return
}
c.JSON(http.StatusOK, gin.H{"items": items})
@@ -676,30 +673,24 @@ func (s *Server) issueDomain(c *gin.Context) {
}
func (s *Server) listServers(c *gin.Context) {
if s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "服务器管理接口尚未配置", errors.New("服务器仓储未配置"))
if !s.requireProjectResourceReader(c) {
return
}
items, err := s.servers.ListServers(c.Request.Context())
items, err := s.projectResources.ListVisibleServers(c.Request.Context(), c.GetString(authenticatedActorKey))
if err != nil {
s.writeError(c, http.StatusInternalServerError, "查询服务器失败", err)
s.writeProjectResourceError(c, err)
return
}
c.JSON(http.StatusOK, gin.H{"items": items})
}
func (s *Server) getServer(c *gin.Context) {
if s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "服务器管理接口尚未配置", errors.New("服务器仓储未配置"))
if !s.requireProjectResourceReader(c) {
return
}
item, err := s.servers.GetServerByID(c.Request.Context(), c.Param("id"))
item, err := s.projectResources.GetVisibleServer(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("id"))
if err != nil {
if repository.IsNotFound(err) {
s.writeError(c, http.StatusNotFound, "服务器不存在", err)
return
}
s.writeError(c, http.StatusInternalServerError, "读取服务器失败", err)
s.writeProjectResourceError(c, err)
return
}
c.JSON(http.StatusOK, item)
@@ -962,24 +953,12 @@ func (s *Server) deleteServer(c *gin.Context) {
}
func (s *Server) listDomainServers(c *gin.Context) {
if !s.requireDomainRepository(c) {
if !s.requireProjectResourceReader(c) {
return
}
if s.servers == nil {
s.writeError(c, http.StatusNotImplemented, "服务器管理接口尚未配置", errors.New("服务器仓储未配置"))
return
}
if _, err := s.repository.GetByID(c.Request.Context(), c.Param("id")); err != nil {
if repository.IsNotFound(err) {
s.writeError(c, http.StatusNotFound, "域名不存在", err)
return
}
s.writeError(c, http.StatusInternalServerError, "读取域名失败", err)
return
}
items, err := s.servers.ListServersByDomainID(c.Request.Context(), c.Param("id"))
items, err := s.projectResources.ListVisibleDomainServers(c.Request.Context(), c.GetString(authenticatedActorKey), c.Param("id"))
if err != nil {
s.writeError(c, http.StatusInternalServerError, "查询域名部署服务器失败", err)
s.writeProjectResourceError(c, err)
return
}
c.JSON(http.StatusOK, gin.H{"items": items})
+11 -4
View File
@@ -43,7 +43,11 @@ func TestHealthAndDomainAPI(t *testing.T) {
t.Fatalf("初始化日志失败:%v", err)
}
defer logger.Close()
server := New(Dependencies{Config: cfg, Logger: logger, Repository: repository.NewSQLDomainRepository(db.DB)})
repo := repository.NewSQLDomainRepository(db.DB)
server := New(Dependencies{
Config: cfg, Logger: logger, Repository: repo,
ProjectResources: projectResourceReaderStub{domains: repo},
})
health := httptest.NewRecorder()
serveAdminHTTP(server, health, httptest.NewRequest(http.MethodGet, "/healthz", nil))
@@ -308,6 +312,9 @@ func TestServerAndDomainAssociationAPI(t *testing.T) {
server := New(Dependencies{
Config: cfg, Repository: repository.NewSQLDomainRepository(db.DB),
Servers: repository.NewSQLServerRepository(db.DB), SSHKeys: sshKeys,
ProjectResources: projectResourceReaderStub{
domains: repository.NewSQLDomainRepository(db.DB), servers: repository.NewSQLServerRepository(db.DB),
},
})
domainRequest := httptest.NewRequest(http.MethodPost, "/api/v1/domains", strings.NewReader(`{"name":"example.com","certificate_type":"single"}`))
@@ -668,10 +675,10 @@ func TestDomainAPIReportsMissingRepository(t *testing.T) {
response := httptest.NewRecorder()
serveAdminHTTP(server, response, request)
if response.Code != http.StatusNotImplemented {
t.Fatalf("域名仓储未配置时应返回 501:%d %s", response.Code, response.Body.String())
if response.Code != http.StatusServiceUnavailable {
t.Fatalf("项目资源授权仓储未配置时应返回 503:%d %s", response.Code, response.Body.String())
}
if !strings.Contains(response.Body.String(), "域名管理接口尚未配置") {
if !strings.Contains(response.Body.String(), "项目资源服务尚未就绪") {
t.Fatalf("缺少域名仓储错误提示:%s", response.Body.String())
}
}
@@ -1,14 +1,44 @@
package httpapi
import (
"context"
"net/http"
"net/http/httptest"
"path/filepath"
"git.pcux.cn/xuans/Scert/backend/internal/config"
"git.pcux.cn/xuans/Scert/backend/internal/deployment"
"git.pcux.cn/xuans/Scert/backend/internal/domain"
"git.pcux.cn/xuans/Scert/backend/internal/repository"
)
// 仅供旧的响应格式与错误脱敏单元测试显式注入;权限验证使用真实 SQL 资源夹具。
// 不在产品构造器或通用请求帮助函数中自动补齐,缺失依赖测试必须保持拒绝。
type projectResourceReaderStub struct {
domains repository.DomainRepository
servers repository.ServerRepository
}
func (r projectResourceReaderStub) ListVisibleDomains(ctx context.Context, _ string) ([]domain.Domain, error) {
return r.domains.List(ctx)
}
func (r projectResourceReaderStub) GetVisibleDomain(ctx context.Context, _ string, id string) (domain.Domain, error) {
return r.domains.GetByID(ctx, id)
}
func (r projectResourceReaderStub) ListVisibleServers(ctx context.Context, _ string) ([]deployment.Server, error) {
return r.servers.ListServers(ctx)
}
func (r projectResourceReaderStub) GetVisibleServer(ctx context.Context, _ string, id string) (deployment.Server, error) {
return r.servers.GetServerByID(ctx, id)
}
func (r projectResourceReaderStub) ListVisibleDomainServers(ctx context.Context, _ string, id string) ([]deployment.Server, error) {
return r.servers.ListServersByDomainID(ctx, id)
}
func readyTestConfig(directory string) config.Config {
cfg := config.Default(directory)
// Linux 默认目录属于正式安装,测试必须显式隔离所有可写路径。