mirror of
https://github.com/MHSanaei/3x-ui.git
synced 2026-08-12 06:10:58 +00:00
refactor: focused service files, leaf subpackages, and an internal/ layout (#5167)
* refactor(service): split client.go into focused files
client.go had grown to 4455 lines mixing ~10 responsibilities. Split it
verbatim into cohesive same-package files (no behavior change):
client.go foundation: ClientService, ClientWithAttachments,
ClientCreatePayload, ErrClientNotInInbound, sqlInChunk
client_locks.go inbound mutation locks, delete tombstones, compactOrphans
client_lookup.go read-only lookups (GetByID, List, EffectiveFlow, ...)
client_link.go inbound association sync (SyncInbound, DetachInbound, ...)
client_crud.go single-client CRUD + validation + protocol defaults
client_inbound_apply.go low-level inbound-settings mutators + by-email setters
client_bulk.go bulk attach/detach/adjust/delete/create + DelDepleted
client_traffic.go traffic-reset paths
client_groups.go client group management
client_paging.go paged listing, filtering, sorting, summary
Every declaration moved unchanged (verified: identical func/type/const/var
signature set before vs after). Imports redistributed per file via goimports.
go build ./..., go vet, and go test ./web/service/... all pass.
* refactor(service): split inbound.go into focused files
inbound.go was 4100 lines. Split it verbatim into cohesive same-package
files (no behavior change):
inbound.go core inbound CRUD + InboundService (keeps pkg doc)
inbound_protocol.go protocol / stream capability helpers
inbound_node.go node/runtime/remote coordination + online tracking
inbound_traffic.go traffic accounting, reset, client stats
inbound_client_ips.go per-client IP tracking
inbound_clients.go client lookups within inbounds + copy-clients
inbound_disable.go auto-disable invalid inbounds/clients
inbound_migration.go DB migrations
inbound_sublink.go subscription link providers
inbound_util.go generic slice/string helpers
Identical func/type/const/var signature set before vs after; package doc
comment preserved on inbound.go. Imports redistributed via goimports.
Build, vet, and go test ./web/service/... all pass.
* refactor(service): split tgbot.go into focused files
tgbot.go was 3738 lines dominated by a 1246-line answerCallback. Split it
verbatim into cohesive same-package files (no behavior change):
tgbot.go lifecycle, bot setup, caches, small utils
tgbot_router.go incoming update / command / callback dispatch
tgbot_send.go outbound messaging primitives
tgbot_client.go client views, actions, subscription links
tgbot_inbound.go inbound listing / pickers
tgbot_report.go server usage, exhausted, online, backups, notifications
Identical func/type/const/var signature set before vs after. Imports
redistributed via goimports. Build, vet, and go test ./web/service/... pass.
* refactor(client): dedupe single-field by-email setters
ResetClientIpLimitByEmail, ResetClientExpiryTimeByEmail, and
ResetClientTrafficLimitByEmail shared an identical ~50-line body that
resolves the inbound by email, confirms the client exists, rewrites a
single-client settings payload, and delegates to UpdateInboundClient.
Extract that into applyClientFieldByEmail(inboundSvc, email, mutate) and
reduce each setter to a 3-line wrapper. Behavior is unchanged: same checks
and error strings, same single-client payload contract, same totalGB guard.
SetClientTelegramUserID (resolves by traffic id, different error text) and
ToggleClientEnableByEmail/SetClientEnableByEmail (different return shape and
a pre-read of the old state) intentionally keep their own bodies.
* refactor(service): extract panel/ subpackage
Move the panel-administration leaf services out of the flat service
package into web/service/panel/ (package panel):
user.go UserService (auth / 2FA / LDAP)
panel.go PanelService (restart / self-update) + version helpers
panel_other.go non-unix RestartPanel
panel_unix.go unix RestartPanel
api_token.go ApiTokenService
websocket.go WebSocketService
panel_test.go version/shellQuote unit tests
These are leaves: they depend on core (SettingService, Release) but no
core file references them, so the extraction creates no import cycle.
Core references are now qualified (service.SettingService, service.Release);
callers in main.go, web/web.go, and web/controller/* updated to panel.*.
Build, vet, and go test ./web/... pass.
* refactor(service): extract integration/ subpackage
Move the external-provider integration leaves into web/service/integration/
(package integration):
warp.go WarpService (Cloudflare WARP)
nord.go NordService (NordVPN)
custom_geo.go CustomGeoService (custom geo asset management)
*_test.go custom_geo / panel-proxy tests
These depend on core (SettingService, ServerService, XraySettingService) but
no core file references them. xray_setting.go stays in core because it calls
the unexported SettingService.saveSetting. The shared isBlockedIP SSRF helper
(used by core url_safety.go and by custom_geo) now has a small copy in each
package rather than being exported. Core references qualified; callers in
web/web.go, web/job/*, and web/controller/* updated to integration.*.
Build, vet, and go test ./web/... pass.
* refactor(service): extract tgbot/ subpackage
Move the Telegram bot (6 files + test) into web/service/tgbot/ (package
tgbot). It is a leaf: it embeds five core services (Inbound/Client/Setting/
Server/Xray) and the core never references it, so no import cycle.
To support the package boundary without changing behavior:
- core exposes XrayProcess() *xray.Process so tgbot keeps calling the
exact same running-process methods it used via the package-level `p`;
- three core methods tgbot calls are exported: ClientService.checkIs-
EnabledByEmail -> CheckIsEnabledByEmail, InboundService.getAllEmails ->
GetAllEmails (callers updated in-package);
- tgbot's embedded-field types and the few core type refs (Status,
ClientCreatePayload, SanitizePublicHTTPURL) are now service-qualified.
Callers in main.go, web/web.go, web/job/*, and web/controller/* updated to
tgbot.*. Build, vet, and go test ./web/... pass.
* refactor(service): extract outbound/ subpackage
OutboundService (outbound.go) imports only neutral packages (config,
database, model, xray) and its production code is referenced by no core or
sibling service file — only by web/controller/xray_setting.go and
web/job/xray_traffic_job.go. Move it to web/service/outbound/ (package
outbound); no core qualification needed inside. Callers updated to outbound.*.
The one coupling was a tiny pure test helper, outboundsContainTag, used by
both outbound.go and the core outbound_subscription_test.go; it now has a
small copy in that test file rather than being shared across the boundary.
Build, vet, and go test ./web/... pass.
* refactor(util): move wireguard into its own subpackage
util/wireguard.go was the lone file of the root `util` package (24 lines,
one exported func GenerateWireguardKeypair), while every other util concern
lives in a focused subpackage (util/common, util/crypto, util/netsafe, ...).
Move it to util/wireguard/ (package wireguard) for consistency; its only
importer, web/service/integration/warp.go, is updated. The root `util`
package no longer exists.
* refactor(sub): drop redundant sub prefix from filenames
Inside package sub the subXxx.go prefix just repeats the package name
(like client_*.go did inside service). Rename for consistency; content and
type names are unchanged:
subController.go -> controller.go
subService.go -> service.go
subClashService.go -> clash_service.go
subJsonService.go -> json_service.go
(+ matching _test.go files)
* refactor(controller): rename xui.go -> spa.go
XUIController serves the panel's single-page-app shell; spa.go names that
role plainly (the other controller files are domain-named). File rename only
— the type stays XUIController. api_docs_test.go keys route base paths by
filename, so its "xui.go" case is updated to "spa.go".
* refactor: move backend packages under internal/
Adopt the idiomatic Go application layout: the backend packages now live
under internal/ (a boundary the toolchain enforces), signalling private
implementation instead of a library-style flat root. No runtime behavior
changes — only import paths and a few build/config paths move.
Moved: config, database, logger, mtproto, sub, util, web, xray -> internal/.
main.go stays at the repo root and tools/openapigen stays under tools/ (both
still import internal/* because the internal rule keys off the module root).
The module path github.com/mhsanaei/3x-ui/v3 is unchanged; 149 .go files had
their import prefix rewritten to .../internal/<pkg>.
Couplings the Go compiler can't see, updated to the new layout:
- frontend i18n imports of web/translation (react.ts, setup.components.ts)
- vite outDir + eslint/tsconfig ignore globs -> internal/web/dist
- Dockerfile COPY paths for web/dist and web/translation
- locale.go os.DirFS("web") disk fallback -> "internal/web"
- .gitignore and ci.yml go:embed stub for internal/web/dist
- api_docs_test.go repo-root relative walk (one level deeper)
- tools/openapigen filesystem package paths; ApiTokenView repointed to the
web/service/panel subpackage and codegen regenerated (clears a stale
type the ci.yml codegen check was failing on)
Verified: go build/vet/test (all packages), and frontend typecheck, lint,
vitest (478 tests), and production build into internal/web/dist.
* fix(config): keep test runs from writing logs into the source tree
GetLogFolder() returns a CWD-relative "./log" on Windows. Under `go test`
the working directory is each package's own folder, so InitLogger (called by
tests in web/job, web/service, xray, web/websocket) created stray log/
directories scattered through the source tree (e.g. internal/web/job/log/).
Redirect to a shared temp folder when testing.Testing() reports a test run.
Production behavior is unchanged: Windows still uses ./log next to the binary
and Linux /var/log/x-ui. The log files were always gitignored (*.log) and
never committed; this just stops the noise at the source.
* docs: move subscription-template guide out of root into docs/
sub_templates/ was a top-level folder holding only a README and no actual
templates (3x-ui ships none by design), referenced nowhere and unlinked from
any doc — it read like an empty placeholder cluttering the repo root.
Move the guide to docs/custom-subscription-templates.md (a proper docs home),
reword its intro to read as documentation rather than a folder note, link it
from the Features list in README.md, and drop the empty sub_templates/ folder.
* fix: update stale web/ path references after the internal/ move
The internal/ migration rewrote Go import paths but left some references to
the old top-level layout in docs, comments, and a few runtime disk paths.
Functional (dev-mode only): the disk-serving fallbacks that read the Vite
build from disk when running from source still pointed at web/dist/, which
moved to internal/web/dist/ — so `os.DirFS`/`os.Stat`/`os.ReadFile` in
internal/web/web.go and internal/sub/{sub,controller}.go are corrected.
Production was unaffected (it serves the embedded FS; verified by the Docker
build), but `go run` with a live frontend build silently fell back to embed.
Docs/comments: frontend/README.md, CONTRIBUTING.md, the claude-issue-bot and
release workflows, the openapigen -root help text, and assorted Go comments
now reference internal/web, internal/database, internal/sub, internal/xray,
etc. Package-name mentions (the "web" package), root paths (main.go,
frontend/, install scripts, /etc/x-ui), routes (/panel/api/xray), and the
historical "web/assets no longer exists" note were intentionally left as-is.
* refactor(web): remove the legacy /xui -> /panel redirect middleware
RedirectMiddleware existed only for backward compatibility with the old
`/xui` URL scheme (301-redirecting /xui and /xui/API to /panel and
/panel/api). That cutover was long ago, so drop the middleware, its
registration in initRouter, and the now-inaccurate "URL redirection"
mention in the middleware package doc. Old /xui URLs now 404 like any other
unknown path. HTTPS auto-redirect and auth redirects are unrelated and stay.
* build: fix .dockerignore for internal/ layout and exclude runtime dir
- web/dist -> internal/web/dist: the embedded frontend moved under internal/,
so the stale exclude no longer matched and the locally-built dist could be
sent to the build context (the frontend stage rebuilds it fresh anyway).
- exclude x-ui/: the local runtime directory (SQLite db, geo .dat files, xray
binaries, certs — ~150MB) was being shipped into the build context for no
reason. Verified the pattern excludes only the directory and still keeps
x-ui.sh, which the Dockerfile copies to /usr/bin/x-ui.
This commit is contained in:
Sanaei
@@ -0,0 +1,31 @@
|
||||
// Package middleware provides HTTP middleware functions for the 3x-ui web panel,
|
||||
// including domain validation utilities.
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"net"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
// DomainValidatorMiddleware returns a Gin middleware that validates the request domain.
|
||||
// It extracts the host from the request, strips any port number, and compares it
|
||||
// against the configured domain. Requests from unauthorized domains are rejected
|
||||
// with HTTP 403 Forbidden status.
|
||||
func DomainValidatorMiddleware(domain string) gin.HandlerFunc {
|
||||
return func(c *gin.Context) {
|
||||
host := c.Request.Host
|
||||
if colonIndex := strings.LastIndex(host, ":"); colonIndex != -1 {
|
||||
host, _, _ = net.SplitHostPort(c.Request.Host)
|
||||
}
|
||||
|
||||
if host != domain {
|
||||
c.AbortWithStatus(http.StatusForbidden)
|
||||
return
|
||||
}
|
||||
|
||||
c.Next()
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,66 @@
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"crypto/rand"
|
||||
"encoding/base64"
|
||||
"net/http"
|
||||
|
||||
"github.com/mhsanaei/3x-ui/v3/internal/web/session"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
// SecurityHeadersMiddleware adds browser hardening headers to panel responses.
|
||||
func SecurityHeadersMiddleware(directHTTPS bool) gin.HandlerFunc {
|
||||
return func(c *gin.Context) {
|
||||
nonce := newCSPNonce()
|
||||
c.Set("csp_nonce", nonce)
|
||||
c.Header("X-Content-Type-Options", "nosniff")
|
||||
c.Header("X-Frame-Options", "DENY")
|
||||
c.Header("Referrer-Policy", "no-referrer")
|
||||
c.Header("Content-Security-Policy", "default-src 'self'; script-src 'self' 'nonce-"+nonce+"'; style-src 'self' 'unsafe-inline'; img-src 'self' data: blob:; font-src 'self' data:; connect-src 'self' ws: wss:; object-src 'none'; frame-ancestors 'none'; base-uri 'self'; form-action 'self'")
|
||||
if directHTTPS {
|
||||
c.Header("Strict-Transport-Security", "max-age=31536000; includeSubDomains")
|
||||
}
|
||||
c.Next()
|
||||
}
|
||||
}
|
||||
|
||||
func newCSPNonce() string {
|
||||
var b [16]byte
|
||||
if _, err := rand.Read(b[:]); err != nil {
|
||||
return ""
|
||||
}
|
||||
return base64.RawStdEncoding.EncodeToString(b[:])
|
||||
}
|
||||
|
||||
// CSRFMiddleware rejects unsafe requests that do not include the session CSRF token.
|
||||
// Bearer-token-authenticated callers (api_authed flag set by APIController.checkAPIAuth)
|
||||
// short-circuit the CSRF check — they are not browser sessions, so the
|
||||
// cross-site request forgery threat model doesn't apply to them.
|
||||
func CSRFMiddleware() gin.HandlerFunc {
|
||||
return func(c *gin.Context) {
|
||||
if c.GetBool("api_authed") {
|
||||
c.Next()
|
||||
return
|
||||
}
|
||||
if isSafeMethod(c.Request.Method) {
|
||||
c.Next()
|
||||
return
|
||||
}
|
||||
if !session.ValidateCSRFToken(c) {
|
||||
c.AbortWithStatus(http.StatusForbidden)
|
||||
return
|
||||
}
|
||||
c.Next()
|
||||
}
|
||||
}
|
||||
|
||||
func isSafeMethod(method string) bool {
|
||||
switch method {
|
||||
case http.MethodGet, http.MethodHead, http.MethodOptions, http.MethodTrace:
|
||||
return true
|
||||
default:
|
||||
return false
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,121 @@
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"testing"
|
||||
|
||||
"github.com/mhsanaei/3x-ui/v3/internal/web/session"
|
||||
|
||||
"github.com/gin-contrib/sessions"
|
||||
"github.com/gin-contrib/sessions/cookie"
|
||||
"github.com/gin-gonic/gin"
|
||||
)
|
||||
|
||||
func TestCSRFMiddlewareAllowsSafeMethods(t *testing.T) {
|
||||
gin.SetMode(gin.TestMode)
|
||||
router := gin.New()
|
||||
router.Use(CSRFMiddleware())
|
||||
router.GET("/safe", func(c *gin.Context) {
|
||||
c.String(http.StatusOK, "ok")
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
req := httptest.NewRequest(http.MethodGet, "/safe", nil)
|
||||
router.ServeHTTP(rec, req)
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rec.Code, http.StatusOK)
|
||||
}
|
||||
}
|
||||
|
||||
func TestCSRFMiddlewareRejectsMissingTokenAndAcceptsValidToken(t *testing.T) {
|
||||
gin.SetMode(gin.TestMode)
|
||||
router := gin.New()
|
||||
store := cookie.NewStore([]byte("01234567890123456789012345678901"))
|
||||
router.Use(sessions.Sessions("3x-ui", store))
|
||||
router.GET("/token", func(c *gin.Context) {
|
||||
token, err := session.EnsureCSRFToken(c)
|
||||
if err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
c.String(http.StatusOK, token)
|
||||
})
|
||||
router.POST("/submit", CSRFMiddleware(), func(c *gin.Context) {
|
||||
c.String(http.StatusOK, "ok")
|
||||
})
|
||||
|
||||
tokenRec := httptest.NewRecorder()
|
||||
tokenReq := httptest.NewRequest(http.MethodGet, "/token", nil)
|
||||
router.ServeHTTP(tokenRec, tokenReq)
|
||||
if tokenRec.Code != http.StatusOK {
|
||||
t.Fatalf("token status = %d, want %d", tokenRec.Code, http.StatusOK)
|
||||
}
|
||||
cookies := tokenRec.Result().Cookies()
|
||||
token := tokenRec.Body.String()
|
||||
|
||||
missingRec := httptest.NewRecorder()
|
||||
missingReq := httptest.NewRequest(http.MethodPost, "/submit", nil)
|
||||
for _, cookie := range cookies {
|
||||
missingReq.AddCookie(cookie)
|
||||
}
|
||||
router.ServeHTTP(missingRec, missingReq)
|
||||
if missingRec.Code != http.StatusForbidden {
|
||||
t.Fatalf("missing token status = %d, want %d", missingRec.Code, http.StatusForbidden)
|
||||
}
|
||||
|
||||
validRec := httptest.NewRecorder()
|
||||
validReq := httptest.NewRequest(http.MethodPost, "/submit", nil)
|
||||
for _, cookie := range cookies {
|
||||
validReq.AddCookie(cookie)
|
||||
}
|
||||
validReq.Header.Set(session.CSRFHeaderName, token)
|
||||
router.ServeHTTP(validRec, validReq)
|
||||
if validRec.Code != http.StatusOK {
|
||||
t.Fatalf("valid token status = %d, want %d", validRec.Code, http.StatusOK)
|
||||
}
|
||||
}
|
||||
|
||||
func TestSecurityHeadersMiddleware(t *testing.T) {
|
||||
gin.SetMode(gin.TestMode)
|
||||
router := gin.New()
|
||||
router.Use(SecurityHeadersMiddleware(true))
|
||||
router.GET("/", func(c *gin.Context) {
|
||||
c.String(http.StatusOK, "ok")
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
router.ServeHTTP(rec, req)
|
||||
|
||||
headers := rec.Result().Header
|
||||
if got := headers.Get("X-Content-Type-Options"); got != "nosniff" {
|
||||
t.Fatalf("X-Content-Type-Options = %q", got)
|
||||
}
|
||||
if got := headers.Get("X-Frame-Options"); got != "DENY" {
|
||||
t.Fatalf("X-Frame-Options = %q", got)
|
||||
}
|
||||
if got := headers.Get("Referrer-Policy"); got != "no-referrer" {
|
||||
t.Fatalf("Referrer-Policy = %q", got)
|
||||
}
|
||||
if got := headers.Get("Strict-Transport-Security"); got == "" {
|
||||
t.Fatal("Strict-Transport-Security should be set for direct HTTPS")
|
||||
}
|
||||
}
|
||||
|
||||
func TestSecurityHeadersMiddlewareSkipsHSTSWithoutDirectHTTPS(t *testing.T) {
|
||||
gin.SetMode(gin.TestMode)
|
||||
router := gin.New()
|
||||
router.Use(SecurityHeadersMiddleware(false))
|
||||
router.GET("/", func(c *gin.Context) {
|
||||
c.String(http.StatusOK, "ok")
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
req := httptest.NewRequest(http.MethodGet, "/", nil)
|
||||
router.ServeHTTP(rec, req)
|
||||
|
||||
if got := rec.Result().Header.Get("Strict-Transport-Security"); got != "" {
|
||||
t.Fatalf("Strict-Transport-Security = %q, want empty", got)
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,111 @@
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"errors"
|
||||
"net/http"
|
||||
"reflect"
|
||||
"strings"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
"github.com/gin-gonic/gin/binding"
|
||||
"github.com/go-playground/validator/v10"
|
||||
|
||||
"github.com/mhsanaei/3x-ui/v3/internal/web/entity"
|
||||
)
|
||||
|
||||
var validate = validator.New(validator.WithRequiredStructEnabled())
|
||||
|
||||
func BindAndValidate[T any](c *gin.Context) (*T, bool) {
|
||||
var dst T
|
||||
if err := c.ShouldBind(&dst); err != nil {
|
||||
writeBindFailure(c, err)
|
||||
return nil, false
|
||||
}
|
||||
if err := validate.Struct(&dst); err != nil {
|
||||
writeBindFailure(c, err)
|
||||
return nil, false
|
||||
}
|
||||
return &dst, true
|
||||
}
|
||||
|
||||
func BindAndValidateInto(c *gin.Context, dst any) bool {
|
||||
if err := c.ShouldBind(dst); err != nil {
|
||||
writeBindFailure(c, err)
|
||||
return false
|
||||
}
|
||||
if err := validate.Struct(dst); err != nil {
|
||||
writeBindFailure(c, err)
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
func BindJSONAndValidate[T any](c *gin.Context) (*T, bool) {
|
||||
var dst T
|
||||
if err := c.ShouldBindWith(&dst, binding.JSON); err != nil {
|
||||
writeBindFailure(c, err)
|
||||
return nil, false
|
||||
}
|
||||
if err := validate.Struct(&dst); err != nil {
|
||||
writeBindFailure(c, err)
|
||||
return nil, false
|
||||
}
|
||||
return &dst, true
|
||||
}
|
||||
|
||||
func BindJSONAndValidateInto(c *gin.Context, dst any) bool {
|
||||
if err := c.ShouldBindWith(dst, binding.JSON); err != nil {
|
||||
writeBindFailure(c, err)
|
||||
return false
|
||||
}
|
||||
if err := validate.Struct(dst); err != nil {
|
||||
writeBindFailure(c, err)
|
||||
return false
|
||||
}
|
||||
return true
|
||||
}
|
||||
|
||||
type FieldIssue struct {
|
||||
Field string `json:"field"`
|
||||
Rule string `json:"rule"`
|
||||
Param string `json:"param,omitempty"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
|
||||
type ValidationPayload struct {
|
||||
Issues []FieldIssue `json:"issues"`
|
||||
Message string `json:"message"`
|
||||
}
|
||||
|
||||
func writeBindFailure(c *gin.Context, err error) {
|
||||
payload := ValidationPayload{Issues: []FieldIssue{}, Message: err.Error()}
|
||||
|
||||
var ve validator.ValidationErrors
|
||||
if errors.As(err, &ve) {
|
||||
payload.Issues = make([]FieldIssue, 0, len(ve))
|
||||
for _, fe := range ve {
|
||||
payload.Issues = append(payload.Issues, FieldIssue{
|
||||
Field: fe.Field(),
|
||||
Rule: fe.Tag(),
|
||||
Param: fe.Param(),
|
||||
Message: fe.Error(),
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
c.AbortWithStatusJSON(http.StatusOK, entity.Msg{
|
||||
Success: false,
|
||||
Msg: "request body failed validation",
|
||||
Obj: payload,
|
||||
})
|
||||
}
|
||||
|
||||
func init() {
|
||||
validate.RegisterTagNameFunc(func(fld reflect.StructField) string {
|
||||
name := strings.SplitN(fld.Tag.Get("json"), ",", 2)[0]
|
||||
if name == "-" || name == "" {
|
||||
return fld.Name
|
||||
}
|
||||
return name
|
||||
})
|
||||
}
|
||||
@@ -0,0 +1,207 @@
|
||||
package middleware
|
||||
|
||||
import (
|
||||
"encoding/json"
|
||||
"net/http"
|
||||
"net/http/httptest"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
"github.com/gin-gonic/gin"
|
||||
|
||||
"github.com/mhsanaei/3x-ui/v3/internal/web/entity"
|
||||
)
|
||||
|
||||
type sampleBody struct {
|
||||
Port int `json:"port" form:"port" validate:"gte=1,lte=65535"`
|
||||
Protocol string `json:"protocol" form:"protocol" validate:"required,oneof=vmess vless trojan"`
|
||||
Tag string `json:"tag" form:"tag"`
|
||||
}
|
||||
|
||||
func newRouter(handler gin.HandlerFunc) *gin.Engine {
|
||||
gin.SetMode(gin.TestMode)
|
||||
r := gin.New()
|
||||
r.POST("/submit", handler)
|
||||
return r
|
||||
}
|
||||
|
||||
func decodeMsg(t *testing.T, body string) entity.Msg {
|
||||
t.Helper()
|
||||
var msg entity.Msg
|
||||
if err := json.Unmarshal([]byte(body), &msg); err != nil {
|
||||
t.Fatalf("decode msg: %v (body=%q)", err, body)
|
||||
}
|
||||
return msg
|
||||
}
|
||||
|
||||
func TestBindAndValidate_ValidPayloadPassesThrough(t *testing.T) {
|
||||
r := newRouter(func(c *gin.Context) {
|
||||
got, ok := BindAndValidate[sampleBody](c)
|
||||
if !ok {
|
||||
t.Fatalf("expected ok=true, got false (body should be valid)")
|
||||
}
|
||||
if got.Port != 443 || got.Protocol != "vless" || got.Tag != "inbound-443" {
|
||||
t.Fatalf("decoded payload mismatch: %+v", got)
|
||||
}
|
||||
c.JSON(http.StatusOK, entity.Msg{Success: true, Msg: "ok"})
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
req := httptest.NewRequest(http.MethodPost, "/submit",
|
||||
strings.NewReader(`{"port":443,"protocol":"vless","tag":"inbound-443"}`))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
r.ServeHTTP(rec, req)
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d (body=%s)", rec.Code, http.StatusOK, rec.Body.String())
|
||||
}
|
||||
if msg := decodeMsg(t, rec.Body.String()); !msg.Success {
|
||||
t.Fatalf("expected Success=true; got %+v", msg)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBindAndValidate_PortOutOfRangeIsRejected(t *testing.T) {
|
||||
r := newRouter(func(c *gin.Context) {
|
||||
if _, ok := BindAndValidate[sampleBody](c); ok {
|
||||
t.Fatal("expected ok=false on invalid port; got true")
|
||||
}
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
req := httptest.NewRequest(http.MethodPost, "/submit",
|
||||
strings.NewReader(`{"port":70000,"protocol":"vless"}`))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
r.ServeHTTP(rec, req)
|
||||
|
||||
msg := decodeMsg(t, rec.Body.String())
|
||||
if msg.Success {
|
||||
t.Fatalf("expected Success=false; got %+v", msg)
|
||||
}
|
||||
payload, err := payloadFromObj(msg.Obj)
|
||||
if err != nil {
|
||||
t.Fatalf("payload extraction: %v", err)
|
||||
}
|
||||
found := false
|
||||
for _, issue := range payload.Issues {
|
||||
if issue.Field == "port" && issue.Rule == "lte" {
|
||||
found = true
|
||||
break
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Fatalf("expected an Issue for field=port rule=lte; got %+v", payload.Issues)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBindAndValidate_ProtocolEnumIsRejected(t *testing.T) {
|
||||
r := newRouter(func(c *gin.Context) {
|
||||
if _, ok := BindAndValidate[sampleBody](c); ok {
|
||||
t.Fatal("expected ok=false on invalid protocol; got true")
|
||||
}
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
req := httptest.NewRequest(http.MethodPost, "/submit",
|
||||
strings.NewReader(`{"port":443,"protocol":"unknown"}`))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
r.ServeHTTP(rec, req)
|
||||
|
||||
msg := decodeMsg(t, rec.Body.String())
|
||||
payload, err := payloadFromObj(msg.Obj)
|
||||
if err != nil {
|
||||
t.Fatalf("payload extraction: %v", err)
|
||||
}
|
||||
found := false
|
||||
for _, issue := range payload.Issues {
|
||||
if issue.Field == "protocol" && issue.Rule == "oneof" {
|
||||
found = true
|
||||
}
|
||||
}
|
||||
if !found {
|
||||
t.Fatalf("expected an Issue for field=protocol rule=oneof; got %+v", payload.Issues)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBindAndValidate_MalformedJSONReturnsMessageButNoIssues(t *testing.T) {
|
||||
r := newRouter(func(c *gin.Context) {
|
||||
if _, ok := BindAndValidate[sampleBody](c); ok {
|
||||
t.Fatal("expected ok=false on malformed JSON; got true")
|
||||
}
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
req := httptest.NewRequest(http.MethodPost, "/submit",
|
||||
strings.NewReader(`{"port":}`))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
r.ServeHTTP(rec, req)
|
||||
|
||||
msg := decodeMsg(t, rec.Body.String())
|
||||
if msg.Success {
|
||||
t.Fatal("expected Success=false on malformed JSON")
|
||||
}
|
||||
payload, err := payloadFromObj(msg.Obj)
|
||||
if err != nil {
|
||||
t.Fatalf("payload extraction: %v", err)
|
||||
}
|
||||
if len(payload.Issues) != 0 {
|
||||
t.Fatalf("expected empty Issues for parse error; got %+v", payload.Issues)
|
||||
}
|
||||
if payload.Message == "" {
|
||||
t.Fatal("expected non-empty Message describing the parse error")
|
||||
}
|
||||
}
|
||||
|
||||
func TestBindAndValidateInto_PreservesPrePopulatedFields(t *testing.T) {
|
||||
r := newRouter(func(c *gin.Context) {
|
||||
dst := &sampleBody{Tag: "preset"}
|
||||
if !BindAndValidateInto(c, dst) {
|
||||
t.Fatal("expected ok=true; got false")
|
||||
}
|
||||
if dst.Tag != "inbound-443" {
|
||||
t.Fatalf("expected payload Tag to overwrite preset; got %q", dst.Tag)
|
||||
}
|
||||
if dst.Port != 443 {
|
||||
t.Fatalf("expected Port=443; got %d", dst.Port)
|
||||
}
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
req := httptest.NewRequest(http.MethodPost, "/submit",
|
||||
strings.NewReader(`{"port":443,"protocol":"trojan","tag":"inbound-443"}`))
|
||||
req.Header.Set("Content-Type", "application/json")
|
||||
r.ServeHTTP(rec, req)
|
||||
|
||||
if rec.Code != http.StatusOK {
|
||||
t.Fatalf("status = %d, want %d", rec.Code, http.StatusOK)
|
||||
}
|
||||
}
|
||||
|
||||
func TestBindJSONAndValidate_RejectsFormEncodedBody(t *testing.T) {
|
||||
r := newRouter(func(c *gin.Context) {
|
||||
if _, ok := BindJSONAndValidate[sampleBody](c); ok {
|
||||
t.Fatal("expected ok=false for form-encoded request to a JSON-only endpoint")
|
||||
}
|
||||
})
|
||||
|
||||
rec := httptest.NewRecorder()
|
||||
req := httptest.NewRequest(http.MethodPost, "/submit",
|
||||
strings.NewReader("port=443&protocol=vless"))
|
||||
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
|
||||
r.ServeHTTP(rec, req)
|
||||
|
||||
if msg := decodeMsg(t, rec.Body.String()); msg.Success {
|
||||
t.Fatalf("expected Success=false; got %+v", msg)
|
||||
}
|
||||
}
|
||||
|
||||
func payloadFromObj(obj any) (ValidationPayload, error) {
|
||||
raw, err := json.Marshal(obj)
|
||||
if err != nil {
|
||||
return ValidationPayload{}, err
|
||||
}
|
||||
var payload ValidationPayload
|
||||
if err := json.Unmarshal(raw, &payload); err != nil {
|
||||
return ValidationPayload{}, err
|
||||
}
|
||||
return payload, nil
|
||||
}
|
||||
Reference in New Issue
Block a user