3x-ui-agent/internal/sub/controller_test.go

package sub

import (
	"encoding/base64"
	"fmt"
	"net/http"
	"net/http/httptest"
	"strings"
	"testing"
	"testing/fstest"

	"github.com/gin-gonic/gin"

	"github.com/mhsanaei/3x-ui/v3/internal/database"
	"github.com/mhsanaei/3x-ui/v3/internal/database/model"
	"github.com/mhsanaei/3x-ui/v3/internal/web/service"
)

var testDistFS = fstest.MapFS{
	"dist/subpage.html": {Data: []byte(`<!doctype html><html><head></head><body><div id="root"></div></body></html>`)},
}

func newSubscriptionTestRouter() *gin.Engine {
	router := gin.New()
	NewSUBController(router.Group("/"))
	return router
}

func TestNewSUBControllerOptions(t *testing.T) {
	gin.SetMode(gin.TestMode)
	defaults := NewSUBController(gin.New().Group("/"))
	if defaults.subPath != "/sub/" {
		t.Fatalf("default path = %q", defaults.subPath)
	}
	if !defaults.subEncrypt || defaults.updateInterval != "12" {
		t.Fatalf("default encryption/update = %v, %q", defaults.subEncrypt, defaults.updateInterval)
	}
	if defaults.subService.remarkTemplate != service.DefaultRemarkTemplate {
		t.Fatalf("default remark template = %q", defaults.subService.remarkTemplate)
	}

	configured := NewSUBController(
		gin.New().Group("/"),
		WithSUBPath("/custom/"),
		WithSUBEncryption(false),
		WithSUBUpdateInterval("24"),
	)
	if configured.subPath != "/custom/" || configured.subEncrypt || configured.updateInterval != "24" {
		t.Fatalf("configured values were not applied: path=%q encrypt=%v update=%q",
			configured.subPath, configured.subEncrypt, configured.updateInterval)
	}
}

func TestSanitizeUserAgentForLog(t *testing.T) {
	if got := sanitizeUserAgentForLog("client/1.0\r\nforged\tline"); got != "client/1.0  forged line" {
		t.Fatalf("sanitizeUserAgentForLog() = %q", got)
	}
	long := strings.Repeat("界", 513)
	if got := sanitizeUserAgentForLog(long); len([]rune(got)) != 512 {
		t.Fatalf("sanitized User-Agent length = %d runes, want 512", len([]rune(got)))
	}
}

func seedSubMtprotoInbound(t *testing.T, subId, tag string, port int) {
	t.Helper()
	db := database.GetDB()
	secret := "ee1234567890abcdef1234567890abcd7777772e636c6f7564666c6172652e636f6d"
	email := tag + "@e"
	settings := fmt.Sprintf(`{"clients":[{"email":%q,"subId":%q,"enable":true,"secret":%q}]}`, email, subId, secret)
	ib := &model.Inbound{
		UserId: 1, Tag: tag, Enable: true, Listen: "203.0.113.5", Port: port,
		Protocol: model.MTProto, Remark: tag, Settings: settings, StreamSettings: "{}",
	}
	if err := db.Create(ib).Error; err != nil {
		t.Fatalf("seed mtproto inbound %s: %v", tag, err)
	}
	client := &model.ClientRecord{Email: email, SubID: subId, Secret: secret, Enable: true}
	if err := db.Create(client).Error; err != nil {
		t.Fatalf("seed client %s: %v", email, err)
	}
	if err := db.Create(&model.ClientInbound{ClientId: client.Id, InboundId: ib.Id}).Error; err != nil {
		t.Fatalf("seed client_inbound %s: %v", email, err)
	}
}

// The link endpoint serves the raw (base64) link list to every client; there
// is no per-client format negotiation left to honour.
func TestSubscriptionServesRawLinksRegardlessOfUserAgent(t *testing.T) {
	seedSubDB(t)
	seedSubMtprotoInbound(t, "s1", "tg", 4490)
	gin.SetMode(gin.TestMode)

	req := httptest.NewRequest(http.MethodGet, "http://sub.example.com/sub/s1", nil)
	req.Header.Set("User-Agent", "Clash-Verge/v2.4.2")
	resp := httptest.NewRecorder()

	newSubscriptionTestRouter().ServeHTTP(resp, req)

	if resp.Code != http.StatusOK {
		t.Fatalf("status = %d, want 200; body=%s", resp.Code, resp.Body.String())
	}
	decoded, err := base64.StdEncoding.DecodeString(resp.Body.String())
	if err != nil {
		t.Fatalf("response is not base64: %v", err)
	}
	if !strings.Contains(string(decoded), "tg://proxy") {
		t.Fatalf("decoded response lacks the Telegram proxy link: %s", decoded)
	}
}

func TestSubscriptionServesRawBase64Links(t *testing.T) {
	seedSubDB(t)
	seedSubInbound(t, "s1", "auto", 4480, 1, `{"network":"tcp","security":"none"}`)
	gin.SetMode(gin.TestMode)

	req := httptest.NewRequest(http.MethodGet, "http://sub.example.com/sub/s1", nil)
	req.Header.Set("User-Agent", "GenericClient/1.10.0")
	resp := httptest.NewRecorder()

	newSubscriptionTestRouter().ServeHTTP(resp, req)

	if resp.Code != http.StatusOK {
		t.Fatalf("status = %d, want 200; body=%s", resp.Code, resp.Body.String())
	}
	decoded, err := base64.StdEncoding.DecodeString(resp.Body.String())
	if err != nil {
		t.Fatalf("raw response is not base64: %v", err)
	}
	if !strings.Contains(string(decoded), "vless://") {
		t.Fatalf("decoded raw response lacks VLESS link: %s", decoded)
	}
}