nite/sub2clash
1
Fork 0
mirror of https://github.com/bestnite/sub2clash.git synced 2025-06-16 20:23:19 +08:00
Code Issues Packages Projects Releases Wiki Activity

add tests

Browse Source
This commit is contained in:
nite
2025-06-12 19:33:14 +10:00
parent 69deed91df
commit c1012750ff
24 changed files with 1830 additions and 440 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
common/sub.go
View File

@ -154,7 +154,10 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
return nil, NewRegexInvalidError("prefix", err)
}
if reg.Match(data) {
p := parser.ParseProxies(strings.Split(string(data), "\n")...)
p, err := parser.ParseProxies(strings.Split(string(data), "\n")...)
if err != nil {
return nil, err
}
newProxies = p
} else {
base64, err := parser.DecodeBase64(string(data))
@ -166,7 +169,10 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
)
return nil, NewSubscriptionParseError(err)
}
p := parser.ParseProxies(strings.Split(base64, "\n")...)
p, err := parser.ParseProxies(strings.Split(base64, "\n")...)
if err != nil {
return nil, err
}
newProxies = p
}
} else {
@ -181,7 +187,11 @@ func BuildSub(clashType model.ClashType, query model.SubConfig, template string,
}
if len(query.Proxy) != 0 {
proxyList = append(proxyList, parser.ParseProxies(query.Proxies...)...)
p, err := parser.ParseProxies(query.Proxies...)
if err != nil {
return nil, err
}
proxyList = append(proxyList, p...)
}
for i := range proxyList {

25
parser/anytls.go
View File

@ -28,16 +28,12 @@ func (p *AnytlsParser) GetType() string {
func (p *AnytlsParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
username := link.User.Username()
@ -49,26 +45,15 @@ func (p *AnytlsParser) Parse(proxy string) (P.Proxy, error) {
query := link.Query()
server := link.Hostname()
if server == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server host")
}
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server port")
}
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Raw: portStr,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPort, err.Error())
}
insecure, sni := query.Get("insecure"), query.Get("sni")
insecureBool := insecure == "1"

16
parser/common.go
View File

@ -6,9 +6,7 @@ import (
"strconv"
"strings"
"github.com/bestnite/sub2clash/logger"
P "github.com/bestnite/sub2clash/model/proxy"
"go.uber.org/zap"
)
func hasPrefix(proxy string, prefixes []string) bool {
@ -65,7 +63,7 @@ func DecodeBase64(s string) (string, error) {
return string(decodeStr), nil
}
func ParseProxies(proxies ...string) []P.Proxy {
func ParseProxies(proxies ...string) ([]P.Proxy, error) {
var result []P.Proxy
for _, proxy := range proxies {
if proxy != "" {
@ -73,15 +71,11 @@ func ParseProxies(proxies ...string) []P.Proxy {
var err error
proxyItem, err = ParseProxyWithRegistry(proxy)
if err == nil {
result = append(result, proxyItem)
} else {
logger.Logger.Debug(
"parse proxy failed", zap.String("proxy", proxy), zap.Error(err),
)
if err != nil {
return nil, err
}
result = append(result, proxyItem)
}
}
return result
return result, nil
}

13
parser/errors.go
View File

@ -1,11 +1,5 @@
package parser
type ParseError struct {
Type ParseErrorType
Message string
Raw string
}
type ParseErrorType string
const (
@ -16,9 +10,6 @@ const (
ErrInvalidBase64 ParseErrorType = "invalid base64"
)
func (e *ParseError) Error() string {
if e.Message != "" {
return string(e.Type) + ": " + e.Message + " \"" + e.Raw + "\""
}
return string(e.Type)
func (e ParseErrorType) Error() string {
return string(e)
}

26
parser/hysteria.go
View File

@ -29,42 +29,26 @@ func (p *HysteriaParser) GetType() string {
func (p *HysteriaParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
server := link.Hostname()
if server == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server host")
}
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server port")
}
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Message: err.Error(),
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPort, err.Error())
}
query := link.Query()

25
parser/hysteria2.go
View File

@ -28,16 +28,12 @@ func (p *Hysteria2Parser) GetType() string {
func (p *Hysteria2Parser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
username := link.User.Username()
@ -49,26 +45,15 @@ func (p *Hysteria2Parser) Parse(proxy string) (P.Proxy, error) {
query := link.Query()
server := link.Hostname()
if server == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server host")
}
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server port")
}
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Raw: portStr,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPort, err.Error())
}
obfs, obfsPassword, insecure, sni := query.Get("obfs"), query.Get("obfs-password"), query.Get("insecure"), query.Get("sni")
insecureBool := insecure == "1"

5
parser/registry.go
View File

@ -1,6 +1,7 @@
package parser
import (
"fmt"
"strings"
"sync"
@ -66,7 +67,7 @@ func GetAllPrefixes() []string {
func ParseProxyWithRegistry(proxy string) (P.Proxy, error) {
proxy = strings.TrimSpace(proxy)
if proxy == "" {
return P.Proxy{}, &ParseError{Type: ErrInvalidStruct, Raw: proxy, Message: "empty proxy string"}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "empty proxy string")
}
for prefix, parser := range registry.parsers {
@ -75,5 +76,5 @@ func ParseProxyWithRegistry(proxy string) (P.Proxy, error) {
}
}
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy, Message: "unsupported protocol"}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, "unsupported protocol")
}

37
parser/shadowsocks.go
View File

@ -32,7 +32,7 @@ func (p *ShadowsocksParser) GetType() string {
// Parse 解析Shadowsocks代理
func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
}
if !strings.Contains(proxy, "@") {
@ -45,11 +45,7 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
}
d, err := DecodeBase64(s[0])
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
if len(s) == 2 {
proxy = "ss://" + d + "#" + s[1]
@ -59,36 +55,21 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
server := link.Hostname()
if server == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server host")
}
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server port")
}
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
method := link.User.Username()
@ -109,11 +90,7 @@ func (p *ShadowsocksParser) Parse(proxy string) (P.Proxy, error) {
if password != "" && isLikelyBase64(password) {
password, err = DecodeBase64(password)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "password decode error",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
}

63
parser/shadowsocksr.go
View File

@ -1,6 +1,7 @@
package parser
import (
"fmt"
"net/url"
"strconv"
"strings"
@ -28,7 +29,7 @@ func (p *ShadowsocksRParser) GetType() string {
func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
}
for _, prefix := range p.GetPrefixes() {
@ -40,32 +41,27 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
proxy, err := DecodeBase64(proxy)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidBase64,
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidBase64, err.Error())
}
serverInfoAndParams := strings.SplitN(proxy, "/?", 2)
parts := strings.Split(serverInfoAndParams[0], ":")
if len(serverInfoAndParams) != 2 {
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, proxy)
}
parts := SplitNRight(serverInfoAndParams[0], ":", 6)
if len(parts) < 6 {
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, proxy)
}
server := parts[0]
protocol := parts[2]
method := parts[3]
obfs := parts[4]
password, err := DecodeBase64(parts[5])
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Raw: proxy,
Message: err.Error(),
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
port, err := ParsePort(parts[1])
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Message: err.Error(),
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPort, err.Error())
}
var obfsParam string
@ -74,11 +70,7 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
if len(serverInfoAndParams) == 2 {
params, err := url.ParseQuery(serverInfoAndParams[1])
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrCannotParseParams,
Raw: proxy,
Message: err.Error(),
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrCannotParseParams, err.Error())
}
if params.Get("obfsparam") != "" {
obfsParam, err = DecodeBase64(params.Get("obfsparam"))
@ -92,11 +84,7 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
remarks = server + ":" + strconv.Itoa(port)
}
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Raw: proxy,
Message: err.Error(),
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
}
@ -121,3 +109,26 @@ func (p *ShadowsocksRParser) Parse(proxy string) (P.Proxy, error) {
func init() {
RegisterParser(&ShadowsocksRParser{})
}
func SplitNRight(s, sep string, n int) []string {
if n <= 0 {
return nil
}
if n == 1 {
return []string{s}
}
parts := strings.Split(s, sep)
if len(parts) <= n {
return parts
}
result := make([]string, n)
for i, j := len(parts)-1, 0; i >= 0; i, j = i-1, j+1 {
if j < n-1 {
result[n-j-1] = parts[len(parts)-j-1]
} else {
result[0] = strings.Join(parts[:i+1], sep)
break
}
}
return result
}

29
parser/socks.go
View File

@ -27,39 +27,24 @@ func (p *SocksParser) GetType() string {
func (p *SocksParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
server := link.Hostname()
if server == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server host")
}
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server port")
}
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Raw: portStr,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPort, err.Error())
}
remarks := link.Fragment
@ -86,6 +71,8 @@ func (p *SocksParser) Parse(proxy string) (P.Proxy, error) {
}
}
tls, udp := link.Query().Get("tls"), link.Query().Get("udp")
return P.Proxy{
Type: p.GetType(),
Name: remarks,
@ -94,6 +81,8 @@ func (p *SocksParser) Parse(proxy string) (P.Proxy, error) {
Port: port,
UserName: username,
Password: password,
TLS: tls == "true",
UDP: udp == "true",
},
}, nil
}

29
parser/trojan.go
View File

@ -28,43 +28,27 @@ func (p *TrojanParser) GetType() string {
func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
password := link.User.Username()
server := link.Hostname()
if server == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server host")
}
portStr := link.Port()
if portStr == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server port",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server port")
}
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Message: err.Error(),
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPort, err.Error())
}
remarks := link.Fragment
@ -74,7 +58,7 @@ func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
remarks = strings.TrimSpace(remarks)
query := link.Query()
network, security, alpnStr, sni, pbk, sid, fp, path, host, serviceName := query.Get("type"), query.Get("security"), query.Get("alpn"), query.Get("sni"), query.Get("pbk"), query.Get("sid"), query.Get("fp"), query.Get("path"), query.Get("host"), query.Get("serviceName")
network, security, alpnStr, sni, pbk, sid, fp, path, host, serviceName, udp := query.Get("type"), query.Get("security"), query.Get("alpn"), query.Get("sni"), query.Get("pbk"), query.Get("sid"), query.Get("fp"), query.Get("path"), query.Get("host"), query.Get("serviceName"), query.Get("udp")
var alpn []string
if strings.Contains(alpnStr, ",") {
@ -88,6 +72,7 @@ func (p *TrojanParser) Parse(proxy string) (P.Proxy, error) {
Port: port,
Password: password,
Network: network,
UDP: udp == "true",
}
if security == "xtls" || security == "tls" {

34
parser/vless.go
View File

@ -28,39 +28,27 @@ func (p *VlessParser) GetType() string {
func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
}
link, err := url.Parse(proxy)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "url parse error",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
server := link.Hostname()
if server == "" {
return P.Proxy{}, &ParseError{
Type: ErrInvalidStruct,
Message: "missing server host",
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, "missing server host")
}
portStr := link.Port()
port, err := ParsePort(portStr)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Message: err.Error(),
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPort, err.Error())
}
query := link.Query()
uuid := link.User.Username()
flow, security, alpnStr, sni, insecure, fp, pbk, sid, path, host, serviceName, _type := query.Get("flow"), query.Get("security"), query.Get("alpn"), query.Get("sni"), query.Get("allowInsecure"), query.Get("fp"), query.Get("pbk"), query.Get("sid"), query.Get("path"), query.Get("host"), query.Get("serviceName"), query.Get("type")
flow, security, alpnStr, sni, insecure, fp, pbk, sid, path, host, serviceName, _type, udp := query.Get("flow"), query.Get("security"), query.Get("alpn"), query.Get("sni"), query.Get("allowInsecure"), query.Get("fp"), query.Get("pbk"), query.Get("sid"), query.Get("path"), query.Get("host"), query.Get("serviceName"), query.Get("type"), query.Get("udp")
insecureBool := insecure == "1"
var alpn []string
@ -80,13 +68,15 @@ func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
Port: port,
UUID: uuid,
Flow: flow,
UDP: udp == "true",
}
if security == "tls" {
result.TLS = true
result.ALPN = alpn
result.SkipCertVerify = insecureBool
result.ClientFingerprint = fp
result.Fingerprint = fp
result.ServerName = sni
}
if security == "reality" {
@ -96,7 +86,7 @@ func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
PublicKey: pbk,
ShortID: sid,
}
result.ClientFingerprint = fp
result.Fingerprint = fp
}
if _type == "ws" {
@ -125,11 +115,7 @@ func (p *VlessParser) Parse(proxy string) (P.Proxy, error) {
hosts, err := url.QueryUnescape(host)
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrCannotParseParams,
Raw: proxy,
Message: err.Error(),
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrCannotParseParams, err.Error())
}
result.Network = "http"
if hosts != "" {

15
parser/vmess.go
View File

@ -2,6 +2,7 @@ package parser
import (
"encoding/json"
"fmt"
"net/url"
"strconv"
"strings"
@ -47,7 +48,7 @@ func (p *VmessParser) GetType() string {
func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
if !hasPrefix(proxy, p.GetPrefixes()) {
return P.Proxy{}, &ParseError{Type: ErrInvalidPrefix, Raw: proxy}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPrefix, proxy)
}
for _, prefix := range p.GetPrefixes() {
@ -58,13 +59,13 @@ func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
}
base64, err := DecodeBase64(proxy)
if err != nil {
return P.Proxy{}, &ParseError{Type: ErrInvalidBase64, Raw: proxy, Message: err.Error()}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidBase64, err.Error())
}
var vmess VmessJson
err = json.Unmarshal([]byte(base64), &vmess)
if err != nil {
return P.Proxy{}, &ParseError{Type: ErrInvalidStruct, Raw: proxy, Message: err.Error()}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
var port int
@ -72,11 +73,7 @@ func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
case string:
port, err = ParsePort(vmess.Port.(string))
if err != nil {
return P.Proxy{}, &ParseError{
Type: ErrInvalidPort,
Message: err.Error(),
Raw: proxy,
}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidPort, err.Error())
}
case float64:
port = int(vmess.Port.(float64))
@ -87,7 +84,7 @@ func (p *VmessParser) Parse(proxy string) (P.Proxy, error) {
case string:
aid, err = strconv.Atoi(vmess.Aid.(string))
if err != nil {
return P.Proxy{}, &ParseError{Type: ErrInvalidStruct, Raw: proxy, Message: err.Error()}
return P.Proxy{}, fmt.Errorf("%w: %s", ErrInvalidStruct, err.Error())
}
case float64:
aid = int(vmess.Aid.(float64))

219
test/parser/anytls_test.go Normal file
View File

@ -0,0 +1,219 @@
package test
import (
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"github.com/bestnite/sub2clash/parser"
)
func TestAnytls_Basic_SimpleLink(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anytls://password123@127.0.0.1:8080#Anytls%20Proxy"
expected := proxy.Proxy{
Type: "anytls",
Name: "Anytls Proxy",
Anytls: proxy.Anytls{
Server: "127.0.0.1",
Port: 8080,
Password: "password123",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestAnytls_Basic_WithSNI(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anytls://password123@proxy.example.com:443?sni=proxy.example.com#Anytls%20SNI"
expected := proxy.Proxy{
Type: "anytls",
Name: "Anytls SNI",
Anytls: proxy.Anytls{
Server: "proxy.example.com",
Port: 443,
Password: "password123",
SNI: "proxy.example.com",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestAnytls_Basic_WithInsecure(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anytls://password123@proxy.example.com:443?insecure=1&sni=proxy.example.com#Anytls%20Insecure"
expected := proxy.Proxy{
Type: "anytls",
Name: "Anytls Insecure",
Anytls: proxy.Anytls{
Server: "proxy.example.com",
Port: 443,
Password: "password123",
SNI: "proxy.example.com",
SkipCertVerify: true,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestAnytls_Basic_IPv6Address(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anytls://password123@[2001:db8::1]:8080#Anytls%20IPv6"
expected := proxy.Proxy{
Type: "anytls",
Name: "Anytls IPv6",
Anytls: proxy.Anytls{
Server: "2001:db8::1",
Port: 8080,
Password: "password123",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestAnytls_Basic_ComplexPassword(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anytls://ComplexPassword!%40%23%24@proxy.example.com:8443?sni=example.com&insecure=1#Anytls%20Full"
expected := proxy.Proxy{
Type: "anytls",
Name: "Anytls Full",
Anytls: proxy.Anytls{
Server: "proxy.example.com",
Port: 8443,
Password: "ComplexPassword!@#$",
SNI: "example.com",
SkipCertVerify: true,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestAnytls_Basic_NoPassword(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anytls://@127.0.0.1:8080#No%20Password"
expected := proxy.Proxy{
Type: "anytls",
Name: "No Password",
Anytls: proxy.Anytls{
Server: "127.0.0.1",
Port: 8080,
Password: "",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestAnytls_Basic_UsernameOnly(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anytls://username@127.0.0.1:8080#Username%20Only"
expected := proxy.Proxy{
Type: "anytls",
Name: "Username Only",
Anytls: proxy.Anytls{
Server: "127.0.0.1",
Port: 8080,
Password: "username",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestAnytls_Error_MissingServer(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anytls://password123@:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestAnytls_Error_MissingPort(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anytls://password123@127.0.0.1"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestAnytls_Error_InvalidPort(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anytls://password123@127.0.0.1:99999"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestAnytls_Error_InvalidProtocol(t *testing.T) {
p := &parser.AnytlsParser{}
input := "anyssl://example.com:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}

198
test/parser/hysteria2_test.go Normal file
View File

@ -0,0 +1,198 @@
package test
import (
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"github.com/bestnite/sub2clash/parser"
)
func TestHysteria2_Basic_SimpleLink(t *testing.T) {
p := &parser.Hysteria2Parser{}
input := "hysteria2://password123@127.0.0.1:8080#Hysteria2%20Proxy"
expected := proxy.Proxy{
Type: "hysteria2",
Name: "Hysteria2 Proxy",
Hysteria2: proxy.Hysteria2{
Server: "127.0.0.1",
Port: 8080,
Password: "password123",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria2_Basic_AltPrefix(t *testing.T) {
p := &parser.Hysteria2Parser{}
input := "hy2://password123@proxy.example.com:443?insecure=1&sni=proxy.example.com#Hysteria2%20Alt"
expected := proxy.Proxy{
Type: "hysteria2",
Name: "Hysteria2 Alt",
Hysteria2: proxy.Hysteria2{
Server: "proxy.example.com",
Port: 443,
Password: "password123",
SNI: "proxy.example.com",
SkipCertVerify: true,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria2_Basic_WithObfs(t *testing.T) {
p := &parser.Hysteria2Parser{}
input := "hysteria2://password123@127.0.0.1:8080?obfs=salamander&obfs-password=obfs123#Hysteria2%20Obfs"
expected := proxy.Proxy{
Type: "hysteria2",
Name: "Hysteria2 Obfs",
Hysteria2: proxy.Hysteria2{
Server: "127.0.0.1",
Port: 8080,
Password: "password123",
Obfs: "salamander",
ObfsPassword: "obfs123",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria2_Basic_IPv6Address(t *testing.T) {
p := &parser.Hysteria2Parser{}
input := "hysteria2://password123@[2001:db8::1]:8080#Hysteria2%20IPv6"
expected := proxy.Proxy{
Type: "hysteria2",
Name: "Hysteria2 IPv6",
Hysteria2: proxy.Hysteria2{
Server: "2001:db8::1",
Port: 8080,
Password: "password123",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria2_Basic_FullConfig(t *testing.T) {
p := &parser.Hysteria2Parser{}
input := "hysteria2://password123@proxy.example.com:443?insecure=1&sni=proxy.example.com&obfs=salamander&obfs-password=obfs123#Hysteria2%20Full"
expected := proxy.Proxy{
Type: "hysteria2",
Name: "Hysteria2 Full",
Hysteria2: proxy.Hysteria2{
Server: "proxy.example.com",
Port: 443,
Password: "password123",
SNI: "proxy.example.com",
Obfs: "salamander",
ObfsPassword: "obfs123",
SkipCertVerify: true,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria2_Basic_NoPassword(t *testing.T) {
p := &parser.Hysteria2Parser{}
input := "hysteria2://@127.0.0.1:8080#No%20Password"
expected := proxy.Proxy{
Type: "hysteria2",
Name: "No Password",
Hysteria2: proxy.Hysteria2{
Server: "127.0.0.1",
Port: 8080,
Password: "",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria2_Error_MissingServer(t *testing.T) {
p := &parser.Hysteria2Parser{}
input := "hysteria2://password123@:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestHysteria2_Error_MissingPort(t *testing.T) {
p := &parser.Hysteria2Parser{}
input := "hysteria2://password123@127.0.0.1"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestHysteria2_Error_InvalidPort(t *testing.T) {
p := &parser.Hysteria2Parser{}
input := "hysteria2://password123@127.0.0.1:99999"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestHysteria2_Error_InvalidProtocol(t *testing.T) {
p := &parser.Hysteria2Parser{}
input := "hysteria://example.com:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}

183
test/parser/hysteria_test.go Normal file
View File

@ -0,0 +1,183 @@
package test
import (
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"github.com/bestnite/sub2clash/parser"
)
func TestHysteria_Basic_SimpleLink(t *testing.T) {
p := &parser.HysteriaParser{}
input := "hysteria://127.0.0.1:8080?protocol=udp&auth=password123&upmbps=100&downmbps=100#Hysteria%20Proxy"
expected := proxy.Proxy{
Type: "hysteria",
Name: "Hysteria Proxy",
Hysteria: proxy.Hysteria{
Server: "127.0.0.1",
Port: 8080,
Protocol: "udp",
Auth: "password123",
Up: "100",
Down: "100",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria_Basic_WithAuthString(t *testing.T) {
p := &parser.HysteriaParser{}
input := "hysteria://proxy.example.com:443?protocol=wechat-video&auth-str=myauth&upmbps=50&downmbps=200&insecure=true#Hysteria%20Auth"
expected := proxy.Proxy{
Type: "hysteria",
Name: "Hysteria Auth",
Hysteria: proxy.Hysteria{
Server: "proxy.example.com",
Port: 443,
Protocol: "wechat-video",
AuthString: "myauth",
Up: "50",
Down: "200",
SkipCertVerify: true,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria_Basic_WithObfs(t *testing.T) {
p := &parser.HysteriaParser{}
input := "hysteria://127.0.0.1:8080?auth=password123&upmbps=100&downmbps=100&obfs=xplus&alpn=h3#Hysteria%20Obfs"
expected := proxy.Proxy{
Type: "hysteria",
Name: "Hysteria Obfs",
Hysteria: proxy.Hysteria{
Server: "127.0.0.1",
Port: 8080,
Auth: "password123",
Up: "100",
Down: "100",
Obfs: "xplus",
ALPN: []string{"h3"},
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria_Basic_IPv6Address(t *testing.T) {
p := &parser.HysteriaParser{}
input := "hysteria://[2001:db8::1]:8080?auth=password123&upmbps=100&downmbps=100#Hysteria%20IPv6"
expected := proxy.Proxy{
Type: "hysteria",
Name: "Hysteria IPv6",
Hysteria: proxy.Hysteria{
Server: "2001:db8::1",
Port: 8080,
Auth: "password123",
Up: "100",
Down: "100",
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria_Basic_MultiALPN(t *testing.T) {
p := &parser.HysteriaParser{}
input := "hysteria://proxy.example.com:443?auth=password123&upmbps=100&downmbps=100&alpn=h3,h2,http/1.1#Hysteria%20Multi%20ALPN"
expected := proxy.Proxy{
Type: "hysteria",
Name: "Hysteria Multi ALPN",
Hysteria: proxy.Hysteria{
Server: "proxy.example.com",
Port: 443,
Auth: "password123",
Up: "100",
Down: "100",
ALPN: []string{"h3", "h2", "http/1.1"},
SkipCertVerify: false,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestHysteria_Error_MissingServer(t *testing.T) {
p := &parser.HysteriaParser{}
input := "hysteria://:8080?auth=password123"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestHysteria_Error_MissingPort(t *testing.T) {
p := &parser.HysteriaParser{}
input := "hysteria://127.0.0.1?auth=password123"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestHysteria_Error_InvalidPort(t *testing.T) {
p := &parser.HysteriaParser{}
input := "hysteria://127.0.0.1:99999?auth=password123"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestHysteria_Error_InvalidProtocol(t *testing.T) {
p := &parser.HysteriaParser{}
input := "hysteria2://example.com:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}

184
test/parser/shadowsocks_test.go Normal file
View File

@ -0,0 +1,184 @@
package test
import (
"errors"
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"github.com/bestnite/sub2clash/parser"
)
func TestShadowsocks_Basic_SimpleLink(t *testing.T) {
p := &parser.ShadowsocksParser{}
input := "ss://YWVzLTI1Ni1nY206cGFzc3dvcmQ=@127.0.0.1:8080"
expected := proxy.Proxy{
Type: "ss",
Name: "127.0.0.1:8080",
ShadowSocks: proxy.ShadowSocks{
Server: "127.0.0.1",
Port: 8080,
Cipher: "aes-256-gcm",
Password: "password",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestShadowsocks_Basic_IPv6Address(t *testing.T) {
p := &parser.ShadowsocksParser{}
input := "ss://YWVzLTI1Ni1nY206cGFzc3dvcmQ=@[2001:db8::1]:8080"
expected := proxy.Proxy{
Type: "ss",
Name: "2001:db8::1:8080",
ShadowSocks: proxy.ShadowSocks{
Server: "2001:db8::1",
Port: 8080,
Cipher: "aes-256-gcm",
Password: "password",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestShadowsocks_Basic_WithRemark(t *testing.T) {
p := &parser.ShadowsocksParser{}
input := "ss://YWVzLTI1Ni1nY206cGFzc3dvcmQ=@proxy.example.com:8080#My%20SS%20Proxy"
expected := proxy.Proxy{
Type: "ss",
Name: "My SS Proxy",
ShadowSocks: proxy.ShadowSocks{
Server: "proxy.example.com",
Port: 8080,
Cipher: "aes-256-gcm",
Password: "password",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestShadowsocks_Advanced_Base64FullEncoded(t *testing.T) {
p := &parser.ShadowsocksParser{}
input := "ss://YWVzLTI1Ni1nY206cGFzc3dvcmRAbG9jYWxob3N0OjgwODA=#Local%20SS"
expected := proxy.Proxy{
Type: "ss",
Name: "Local SS",
ShadowSocks: proxy.ShadowSocks{
Server: "localhost",
Port: 8080,
Cipher: "aes-256-gcm",
Password: "password",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestShadowsocks_Advanced_PlainUserPassword(t *testing.T) {
p := &parser.ShadowsocksParser{}
input := "ss://aes-256-gcm:password@192.168.1.1:8080"
expected := proxy.Proxy{
Type: "ss",
Name: "192.168.1.1:8080",
ShadowSocks: proxy.ShadowSocks{
Server: "192.168.1.1",
Port: 8080,
Cipher: "aes-256-gcm",
Password: "password",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestShadowsocks_Advanced_ChaCha20Cipher(t *testing.T) {
p := &parser.ShadowsocksParser{}
input := "ss://chacha20-poly1305:mypassword@server.com:443#ChaCha20"
expected := proxy.Proxy{
Type: "ss",
Name: "ChaCha20",
ShadowSocks: proxy.ShadowSocks{
Server: "server.com",
Port: 443,
Cipher: "chacha20-poly1305",
Password: "mypassword",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
// 错误处理测试
func TestShadowsocks_Error_MissingServer(t *testing.T) {
p := &parser.ShadowsocksParser{}
input := "ss://YWVzLTI1Ni1nY206cGFzc3dvcmQ=@:8080"
_, err := p.Parse(input)
if !errors.Is(err, parser.ErrInvalidStruct) {
t.Errorf("Error is not expected: %v", err)
}
}
func TestShadowsocks_Error_MissingPort(t *testing.T) {
p := &parser.ShadowsocksParser{}
input := "ss://YWVzLTI1Ni1nY206cGFzc3dvcmQ=@127.0.0.1"
_, err := p.Parse(input)
if !errors.Is(err, parser.ErrInvalidStruct) {
t.Errorf("Error is not expected: %v", err)
}
}
func TestShadowsocks_Error_InvalidProtocol(t *testing.T) {
p := &parser.ShadowsocksParser{}
input := "http://example.com:8080"
_, err := p.Parse(input)
if !errors.Is(err, parser.ErrInvalidPrefix) {
t.Errorf("Error is not expected: %v", err)
}
}

112
test/parser/shadowsocksr_test.go Normal file
View File

@ -0,0 +1,112 @@
package test
import (
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"github.com/bestnite/sub2clash/parser"
)
func TestShadowsocksR_Basic_SimpleLink(t *testing.T) {
p := &parser.ShadowsocksRParser{}
input := "ssr://MTI3LjAuMC4xOjQ0MzpvcmlnaW46YWVzLTE5Mi1jZmI6cGxhaW46TVRJek1USXovP2dyb3VwPVpHVm1ZWFZzZEEmcmVtYXJrcz1TRUZJUVE"
expected := proxy.Proxy{
Type: "ssr",
Name: "HAHA",
ShadowSocksR: proxy.ShadowSocksR{
Server: "127.0.0.1",
Port: 443,
Cipher: "aes-192-cfb",
Password: "123123",
ObfsParam: "",
Obfs: "plain",
Protocol: "origin",
ProtocolParam: "",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestShadowsocksR_Basic_WithParams(t *testing.T) {
p := &parser.ShadowsocksRParser{}
input := "ssr://MTI3LjAuMC4xOjQ0MzpvcmlnaW46YWVzLTE5Mi1jZmI6dGxzMS4wX3Nlc3Npb25fYXV0aDpNVEl6TVRJei8/b2Jmc3BhcmFtPWIySm1jeTF3WVhKaGJXVjBaWEkmcHJvdG9wYXJhbT1jSEp2ZEc5allXd3RjR0Z5WVcxbGRHVnkmZ3JvdXA9WkdWbVlYVnNkQSZyZW1hcmtzPVNFRklRUQ"
expected := proxy.Proxy{
Type: "ssr",
Name: "HAHA",
ShadowSocksR: proxy.ShadowSocksR{
Server: "127.0.0.1",
Port: 443,
Cipher: "aes-192-cfb",
Password: "123123",
ObfsParam: "obfs-parameter",
Obfs: "tls1.0_session_auth",
Protocol: "origin",
ProtocolParam: "protocal-parameter",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestShadowsocksR_Basic_IPv6Address(t *testing.T) {
p := &parser.ShadowsocksRParser{}
input := "ssr://WzIwMDE6MGRiODo4NWEzOjAwMDA6MDAwMDo4YTJlOjAzNzA6NzMzNF06NDQzOm9yaWdpbjphZXMtMTkyLWNmYjpwbGFpbjpNVEl6TVRJei8/Z3JvdXA9WkdWbVlYVnNkQSZyZW1hcmtzPVNFRklRUQ"
expected := proxy.Proxy{
Type: "ssr",
Name: "HAHA",
ShadowSocksR: proxy.ShadowSocksR{
Server: "[2001:0db8:85a3:0000:0000:8a2e:0370:7334]",
Port: 443,
Cipher: "aes-192-cfb",
Password: "123123",
ObfsParam: "",
Obfs: "plain",
Protocol: "origin",
ProtocolParam: "",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestShadowsocksR_Error_InvalidBase64(t *testing.T) {
p := &parser.ShadowsocksRParser{}
input := "ssr://invalid_base64"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestShadowsocksR_Error_InvalidProtocol(t *testing.T) {
p := &parser.ShadowsocksRParser{}
input := "ss://example.com:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}

168
test/parser/socks_test.go Normal file
View File

@ -0,0 +1,168 @@
package test
import (
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"github.com/bestnite/sub2clash/parser"
)
func TestSocks_Basic_SimpleLink(t *testing.T) {
p := &parser.SocksParser{}
input := "socks://user:pass@127.0.0.1:1080#SOCKS%20Proxy"
expected := proxy.Proxy{
Type: "socks5",
Name: "SOCKS Proxy",
Socks: proxy.Socks{
Server: "127.0.0.1",
Port: 1080,
UserName: "user",
Password: "pass",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestSocks_Basic_NoAuth(t *testing.T) {
p := &parser.SocksParser{}
input := "socks://127.0.0.1:1080#SOCKS%20No%20Auth"
expected := proxy.Proxy{
Type: "socks5",
Name: "SOCKS No Auth",
Socks: proxy.Socks{
Server: "127.0.0.1",
Port: 1080,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestSocks_Basic_IPv6Address(t *testing.T) {
p := &parser.SocksParser{}
input := "socks://user:pass@[2001:db8::1]:1080#SOCKS%20IPv6"
expected := proxy.Proxy{
Type: "socks5",
Name: "SOCKS IPv6",
Socks: proxy.Socks{
Server: "2001:db8::1",
Port: 1080,
UserName: "user",
Password: "pass",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestSocks_Basic_WithTLS(t *testing.T) {
p := &parser.SocksParser{}
input := "socks://user:pass@127.0.0.1:1080?tls=true&sni=example.com#SOCKS%20TLS"
expected := proxy.Proxy{
Type: "socks5",
Name: "SOCKS TLS",
Socks: proxy.Socks{
Server: "127.0.0.1",
Port: 1080,
UserName: "user",
Password: "pass",
TLS: true,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestSocks_Basic_WithUDP(t *testing.T) {
p := &parser.SocksParser{}
input := "socks://user:pass@127.0.0.1:1080?udp=true#SOCKS%20UDP"
expected := proxy.Proxy{
Type: "socks5",
Name: "SOCKS UDP",
Socks: proxy.Socks{
Server: "127.0.0.1",
Port: 1080,
UserName: "user",
Password: "pass",
UDP: true,
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestSocks_Error_MissingServer(t *testing.T) {
p := &parser.SocksParser{}
input := "socks://user:pass@:1080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestSocks_Error_MissingPort(t *testing.T) {
p := &parser.SocksParser{}
input := "socks://user:pass@127.0.0.1"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestSocks_Error_InvalidPort(t *testing.T) {
p := &parser.SocksParser{}
input := "socks://user:pass@127.0.0.1:99999"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestSocks_Error_InvalidProtocol(t *testing.T) {
p := &parser.SocksParser{}
input := "ss://example.com:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}

182
test/parser/trojan_test.go Normal file
View File

@ -0,0 +1,182 @@
package test
import (
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"github.com/bestnite/sub2clash/parser"
)
func TestTrojan_Basic_SimpleLink(t *testing.T) {
p := &parser.TrojanParser{}
input := "trojan://password@127.0.0.1:443#Trojan%20Proxy"
expected := proxy.Proxy{
Type: "trojan",
Name: "Trojan Proxy",
Trojan: proxy.Trojan{
Server: "127.0.0.1",
Port: 443,
Password: "password",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestTrojan_Basic_WithTLS(t *testing.T) {
p := &parser.TrojanParser{}
input := "trojan://password@127.0.0.1:443?security=tls&sni=example.com&alpn=h2,http/1.1#Trojan%20TLS"
expected := proxy.Proxy{
Type: "trojan",
Name: "Trojan TLS",
Trojan: proxy.Trojan{
Server: "127.0.0.1",
Port: 443,
Password: "password",
ALPN: []string{"h2", "http/1.1"},
SNI: "example.com",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestTrojan_Basic_WithReality(t *testing.T) {
p := &parser.TrojanParser{}
input := "trojan://password@127.0.0.1:443?security=reality&sni=example.com&pbk=publickey123&sid=shortid123&fp=chrome#Trojan%20Reality"
expected := proxy.Proxy{
Type: "trojan",
Name: "Trojan Reality",
Trojan: proxy.Trojan{
Server: "127.0.0.1",
Port: 443,
Password: "password",
SNI: "example.com",
RealityOpts: proxy.RealityOptions{
PublicKey: "publickey123",
ShortID: "shortid123",
},
Fingerprint: "chrome",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestTrojan_Basic_WithWebSocket(t *testing.T) {
p := &parser.TrojanParser{}
input := "trojan://password@127.0.0.1:443?type=ws&path=/ws&host=example.com#Trojan%20WS"
expected := proxy.Proxy{
Type: "trojan",
Name: "Trojan WS",
Trojan: proxy.Trojan{
Server: "127.0.0.1",
Port: 443,
Password: "password",
Network: "ws",
WSOpts: proxy.WSOptions{
Path: "/ws",
Headers: map[string]string{
"Host": "example.com",
},
},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestTrojan_Basic_WithGrpc(t *testing.T) {
p := &parser.TrojanParser{}
input := "trojan://password@127.0.0.1:443?type=grpc&serviceName=grpc_service#Trojan%20gRPC"
expected := proxy.Proxy{
Type: "trojan",
Name: "Trojan gRPC",
Trojan: proxy.Trojan{
Server: "127.0.0.1",
Port: 443,
Password: "password",
Network: "grpc",
GrpcOpts: proxy.GrpcOptions{
GrpcServiceName: "grpc_service",
},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestTrojan_Error_MissingServer(t *testing.T) {
p := &parser.TrojanParser{}
input := "trojan://password@:443"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestTrojan_Error_MissingPort(t *testing.T) {
p := &parser.TrojanParser{}
input := "trojan://password@127.0.0.1"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestTrojan_Error_InvalidPort(t *testing.T) {
p := &parser.TrojanParser{}
input := "trojan://password@127.0.0.1:99999"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestTrojan_Error_InvalidProtocol(t *testing.T) {
p := &parser.TrojanParser{}
input := "ss://example.com:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}

24
test/parser/utils.go Normal file
View File

@ -0,0 +1,24 @@
package test
import (
"reflect"
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"gopkg.in/yaml.v3"
)
func validateResult(t *testing.T, expected proxy.Proxy, result proxy.Proxy) {
t.Helper()
if result.Type != expected.Type {
t.Errorf("Type mismatch: expected %s, got %s", expected.Type, result.Type)
}
if !reflect.DeepEqual(expected, result) {
expectedYaml, _ := yaml.Marshal(expected)
resultYaml, _ := yaml.Marshal(result)
t.Errorf("Structure mismatch: \nexpected:\n %s\ngot:\n %s", string(expectedYaml), string(resultYaml))
}
}

214
test/parser/vless_test.go Normal file
View File

@ -0,0 +1,214 @@
package test
import (
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"github.com/bestnite/sub2clash/parser"
)
func TestVless_Basic_SimpleLink(t *testing.T) {
p := &parser.VlessParser{}
input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1:8080#VLESS%20Proxy"
expected := proxy.Proxy{
Type: "vless",
Name: "VLESS Proxy",
Vless: proxy.Vless{
Server: "127.0.0.1",
Port: 8080,
UUID: "b831b0c4-33b7-4873-9834-28d66d87d4ce",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVless_Basic_WithTLS(t *testing.T) {
p := &parser.VlessParser{}
input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1:443?security=tls&sni=example.com&alpn=h2,http/1.1#VLESS%20TLS"
expected := proxy.Proxy{
Type: "vless",
Name: "VLESS TLS",
Vless: proxy.Vless{
Server: "127.0.0.1",
Port: 443,
UUID: "b831b0c4-33b7-4873-9834-28d66d87d4ce",
TLS: true,
ALPN: []string{"h2", "http/1.1"},
ServerName: "example.com",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVless_Basic_WithReality(t *testing.T) {
p := &parser.VlessParser{}
input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1:443?security=reality&sni=example.com&pbk=publickey123&sid=shortid123&fp=chrome#VLESS%20Reality"
expected := proxy.Proxy{
Type: "vless",
Name: "VLESS Reality",
Vless: proxy.Vless{
Server: "127.0.0.1",
Port: 443,
UUID: "b831b0c4-33b7-4873-9834-28d66d87d4ce",
TLS: true,
ServerName: "example.com",
RealityOpts: proxy.RealityOptions{
PublicKey: "publickey123",
ShortID: "shortid123",
},
Fingerprint: "chrome",
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVless_Basic_WithWebSocket(t *testing.T) {
p := &parser.VlessParser{}
input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1:443?type=ws&path=/ws&host=example.com#VLESS%20WS"
expected := proxy.Proxy{
Type: "vless",
Name: "VLESS WS",
Vless: proxy.Vless{
Server: "127.0.0.1",
Port: 443,
UUID: "b831b0c4-33b7-4873-9834-28d66d87d4ce",
Network: "ws",
WSOpts: proxy.WSOptions{
Path: "/ws",
Headers: map[string]string{
"Host": "example.com",
},
},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVless_Basic_WithGrpc(t *testing.T) {
p := &parser.VlessParser{}
input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1:443?type=grpc&serviceName=grpc_service#VLESS%20gRPC"
expected := proxy.Proxy{
Type: "vless",
Name: "VLESS gRPC",
Vless: proxy.Vless{
Server: "127.0.0.1",
Port: 443,
UUID: "b831b0c4-33b7-4873-9834-28d66d87d4ce",
Network: "grpc",
GrpcOpts: proxy.GrpcOptions{
GrpcServiceName: "grpc_service",
},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVless_Basic_WithHTTP(t *testing.T) {
p := &parser.VlessParser{}
input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1:443?type=http&path=/path1,/path2&host=host1.com,host2.com#VLESS%20HTTP"
expected := proxy.Proxy{
Type: "vless",
Name: "VLESS HTTP",
Vless: proxy.Vless{
Server: "127.0.0.1",
Port: 443,
UUID: "b831b0c4-33b7-4873-9834-28d66d87d4ce",
Network: "http",
HTTPOpts: proxy.HTTPOptions{
Path: []string{"/path1", "/path2"},
Headers: map[string][]string{
"host": {"host1.com", "host2.com"},
},
},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVless_Error_MissingServer(t *testing.T) {
p := &parser.VlessParser{}
input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestVless_Error_MissingPort(t *testing.T) {
p := &parser.VlessParser{}
input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestVless_Error_InvalidPort(t *testing.T) {
p := &parser.VlessParser{}
input := "vless://b831b0c4-33b7-4873-9834-28d66d87d4ce@127.0.0.1:99999"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestVless_Error_InvalidProtocol(t *testing.T) {
p := &parser.VlessParser{}
input := "ss://example.com:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}

232
test/parser/vmess_test.go Normal file
View File

@ -0,0 +1,232 @@
package test
import (
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"github.com/bestnite/sub2clash/parser"
)
func TestVmess_Basic_SimpleLink(t *testing.T) {
p := &parser.VmessParser{}
input := "vmess://eyJhZGQiOiIxMjcuMC4wLjEiLCJhaWQiOiIwIiwiaWQiOiIxMjM0NTY3OC05MDEyLTM0NTYtNzg5MC0xMjM0NTY3ODkwMTIiLCJuZXQiOiJ3cyIsInBvcnQiOiI0NDMiLCJwcyI6IkhBSEEiLCJ0bHMiOiJ0bHMiLCJ0eXBlIjoibm9uZSIsInYiOiIyIn0="
expected := proxy.Proxy{
Type: "vmess",
Name: "HAHA",
Vmess: proxy.Vmess{
UUID: "12345678-9012-3456-7890-123456789012",
AlterID: 0,
Cipher: "auto",
Server: "127.0.0.1",
Port: 443,
TLS: true,
Network: "ws",
WSOpts: proxy.WSOptions{
Path: "/",
Headers: map[string]string{
"Host": "127.0.0.1",
},
},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVmess_Basic_WithPath(t *testing.T) {
p := &parser.VmessParser{}
input := "vmess://eyJhZGQiOiIxMjcuMC4wLjEiLCJhaWQiOiIwIiwiaWQiOiIxMjM0NTY3OC05MDEyLTM0NTYtNzg5MC0xMjM0NTY3ODkwMTIiLCJuZXQiOiJ3cyIsInBhdGgiOiIvd3MiLCJwb3J0IjoiNDQzIiwicHMiOiJIQUNLIiwidGxzIjoidGxzIiwidHlwZSI6Im5vbmUiLCJ2IjoiMiJ9"
expected := proxy.Proxy{
Type: "vmess",
Name: "HACK",
Vmess: proxy.Vmess{
UUID: "12345678-9012-3456-7890-123456789012",
AlterID: 0,
Cipher: "auto",
Server: "127.0.0.1",
Port: 443,
TLS: true,
Network: "ws",
WSOpts: proxy.WSOptions{
Path: "/ws",
Headers: map[string]string{
"Host": "127.0.0.1",
},
},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVmess_Basic_WithHost(t *testing.T) {
p := &parser.VmessParser{}
input := "vmess://eyJhZGQiOiIxMjcuMC4wLjEiLCJhaWQiOiIwIiwiaG9zdCI6ImV4YW1wbGUuY29tIiwiaWQiOiIxMjM0NTY3OC05MDEyLTM0NTYtNzg5MC0xMjM0NTY3ODkwMTIiLCJuZXQiOiJ3cyIsInBvcnQiOiI0NDMiLCJwcyI6IkhBSEEiLCJ0bHMiOiJ0bHMiLCJ0eXBlIjoibm9uZSIsInYiOiIyIn0="
expected := proxy.Proxy{
Type: "vmess",
Name: "HAHA",
Vmess: proxy.Vmess{
UUID: "12345678-9012-3456-7890-123456789012",
AlterID: 0,
Cipher: "auto",
Server: "127.0.0.1",
Port: 443,
TLS: true,
Network: "ws",
WSOpts: proxy.WSOptions{
Path: "/",
Headers: map[string]string{
"Host": "example.com",
},
},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVmess_Basic_WithSNI(t *testing.T) {
p := &parser.VmessParser{}
input := "vmess://eyJhZGQiOiIxMjcuMC4wLjEiLCJhaWQiOiIwIiwiaWQiOiIxMjM0NTY3OC05MDEyLTM0NTYtNzg5MC0xMjM0NTY3ODkwMTIiLCJuZXQiOiJ3cyIsInBvcnQiOiI0NDMiLCJwcyI6IkhBSEEiLCJzbmkiOiJleGFtcGxlLmNvbSIsInRscyI6InRscyIsInR5cGUiOiJub25lIiwidiI6IjIifQ=="
expected := proxy.Proxy{
Type: "vmess",
Name: "HAHA",
Vmess: proxy.Vmess{
UUID: "12345678-9012-3456-7890-123456789012",
AlterID: 0,
Cipher: "auto",
Server: "127.0.0.1",
Port: 443,
TLS: true,
Network: "ws",
ServerName: "example.com",
WSOpts: proxy.WSOptions{
Path: "/",
Headers: map[string]string{
"Host": "127.0.0.1",
},
},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVmess_Basic_WithAlterID(t *testing.T) {
p := &parser.VmessParser{}
input := "vmess://eyJhZGQiOiIxMjcuMC4wLjEiLCJhaWQiOiIxIiwiaWQiOiIxMjM0NTY3OC05MDEyLTM0NTYtNzg5MC0xMjM0NTY3ODkwMTIiLCJuZXQiOiJ3cyIsInBvcnQiOiI0NDMiLCJwcyI6IkhBSEEiLCJ0bHMiOiJ0bHMiLCJ0eXBlIjoibm9uZSIsInYiOiIyIn0="
expected := proxy.Proxy{
Type: "vmess",
Name: "HAHA",
Vmess: proxy.Vmess{
UUID: "12345678-9012-3456-7890-123456789012",
AlterID: 1,
Cipher: "auto",
Server: "127.0.0.1",
Port: 443,
TLS: true,
Network: "ws",
WSOpts: proxy.WSOptions{
Path: "/",
Headers: map[string]string{
"Host": "127.0.0.1",
},
},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVmess_Basic_GRPC(t *testing.T) {
p := &parser.VmessParser{}
input := "vmess://eyJhZGQiOiIxMjcuMC4wLjEiLCJhaWQiOiIwIiwiaWQiOiIxMjM0NTY3OC05MDEyLTM0NTYtNzg5MC0xMjM0NTY3ODkwMTIiLCJuZXQiOiJncnBjIiwicG9ydCI6IjQ0MyIsInBzIjoiSEFIQSIsInRscyI6InRscyIsInR5cGUiOiJub25lIiwidiI6IjIifQ=="
expected := proxy.Proxy{
Type: "vmess",
Name: "HAHA",
Vmess: proxy.Vmess{
UUID: "12345678-9012-3456-7890-123456789012",
AlterID: 0,
Cipher: "auto",
Server: "127.0.0.1",
Port: 443,
TLS: true,
Network: "grpc",
GrpcOpts: proxy.GrpcOptions{},
},
}
result, err := p.Parse(input)
if err != nil {
t.Errorf("Unexpected error: %v", err)
return
}
validateResult(t, expected, result)
}
func TestVmess_Error_InvalidBase64(t *testing.T) {
p := &parser.VmessParser{}
input := "vmess://invalid_base64"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestVmess_Error_InvalidJSON(t *testing.T) {
p := &parser.VmessParser{}
input := "vmess://eyJpbnZhbGlkIjoianNvbn0="
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}
func TestVmess_Error_InvalidProtocol(t *testing.T) {
p := &parser.VmessParser{}
input := "ss://example.com:8080"
_, err := p.Parse(input)
if err == nil {
t.Errorf("Expected error but got none")
}
}

221
test/socks_test.go
View File

@ -1,221 +0,0 @@
package test
import (
"testing"
"github.com/bestnite/sub2clash/model/proxy"
"github.com/bestnite/sub2clash/parser"
)
func TestSocksParser_Parse(t *testing.T) {
p := &parser.SocksParser{}
tests := []struct {
name string
input string
expected proxy.Proxy
expectError bool
errorType string
}{
{
name: "无认证SOCKS5代理 - IPv4",
input: "socks://127.0.0.1:1080",
expected: proxy.Proxy{
Type: "socks5",
Name: "127.0.0.1:1080",
Socks: proxy.Socks{
Server: "127.0.0.1",
Port: 1080,
UserName: "",
Password: "",
},
},
expectError: false,
},
{
name: "无认证SOCKS5代理 - IPv6",
input: "socks://[2001:db8::1]:1080",
expected: proxy.Proxy{
Type: "socks5",
Name: "2001:db8::1:1080",
Socks: proxy.Socks{
Server: "2001:db8::1",
Port: 1080,
UserName: "",
Password: "",
},
},
expectError: false,
},
{
name: "明文用户名密码认证 - IPv4",
input: "socks://user:pass@127.0.0.1:1080",
expected: proxy.Proxy{
Type: "socks5",
Name: "127.0.0.1:1080",
Socks: proxy.Socks{
Server: "127.0.0.1",
Port: 1080,
UserName: "user",
Password: "pass",
},
},
expectError: false,
},
{
name: "明文用户名密码认证 - IPv6",
input: "socks://user:pass@[2001:db8::1]:1080",
expected: proxy.Proxy{
Type: "socks5",
Name: "2001:db8::1:1080",
Socks: proxy.Socks{
Server: "2001:db8::1",
Port: 1080,
UserName: "user",
Password: "pass",
},
},
expectError: false,
},
{
name: "Base64编码的用户名密码",
input: "socks://dXNlcm5hbWU6cGFzc3dvcmQ=@127.0.0.1:1080",
expected: proxy.Proxy{
Type: "socks5",
Name: "127.0.0.1:1080",
Socks: proxy.Socks{
Server: "127.0.0.1",
Port: 1080,
UserName: "username",
Password: "password",
},
},
expectError: false,
},
{
name: "带Fragment的URL",
input: "socks://username:password@proxy.example.com:1080#MyProxy",
expected: proxy.Proxy{
Type: "socks5",
Name: "MyProxy",
Socks: proxy.Socks{
Server: "proxy.example.com",
Port: 1080,
UserName: "username",
Password: "password",
},
},
expectError: false,
},
{
name: "只有用户名没有密码",
input: "socks://username@127.0.0.1:1080",
expected: proxy.Proxy{
Type: "socks5",
Name: "127.0.0.1:1080",
Socks: proxy.Socks{
Server: "127.0.0.1",
Port: 1080,
UserName: "username",
Password: "",
},
},
expectError: false,
},
{
name: "Base64编码只有用户名",
input: "socks://dXNlcm5hbWU=@127.0.0.1:1080",
expected: proxy.Proxy{
Type: "socks5",
Name: "127.0.0.1:1080",
Socks: proxy.Socks{
Server: "127.0.0.1",
Port: 1080,
UserName: "username",
Password: "",
},
},
expectError: false,
},
{
name: "域名代理",
input: "socks://proxy.example.com:8080",
expected: proxy.Proxy{
Type: "socks5",
Name: "proxy.example.com:8080",
Socks: proxy.Socks{
Server: "proxy.example.com",
Port: 8080,
UserName: "",
Password: "",
},
},
expectError: false,
},
{
name: "特殊字符用户名密码",
input: "socks://user%40domain:p%40ss%21@127.0.0.1:1080",
expected: proxy.Proxy{
Type: "socks5",
Name: "127.0.0.1:1080",
Socks: proxy.Socks{
Server: "127.0.0.1",
Port: 1080,
UserName: "user@domain",
Password: "p@ss!",
},
},
expectError: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := p.Parse(tt.input)
if tt.expectError {
if err == nil {
t.Errorf("期望出现错误，但没有错误")
return
}
if parseErr, ok := err.(*parser.ParseError); ok {
if tt.errorType != "" && string(parseErr.Type) != tt.errorType {
t.Errorf("错误类型不匹配: 期望 %s, 实际 %s", tt.errorType, string(parseErr.Type))
}
}
return
}
if err != nil {
t.Errorf("意外的错误: %v", err)
return
}
// 验证解析结果
if result.Type != tt.expected.Type {
t.Errorf("Type不匹配: 期望 %s, 实际 %s", tt.expected.Type, result.Type)
}
if result.Name != tt.expected.Name {
t.Errorf("Name不匹配: 期望 %s, 实际 %s", tt.expected.Name, result.Name)
}
if result.Socks.Server != tt.expected.Socks.Server {
t.Errorf("Server不匹配: 期望 %s, 实际 %s", tt.expected.Socks.Server, result.Socks.Server)
}
if result.Socks.Port != tt.expected.Socks.Port {
t.Errorf("Port不匹配: 期望 %d, 实际 %d", tt.expected.Socks.Port, result.Socks.Port)
}
if result.Socks.UserName != tt.expected.Socks.UserName {
t.Errorf("UserName不匹配: 期望 %s, 实际 %s", tt.expected.Socks.UserName, result.Socks.UserName)
}
if result.Socks.Password != tt.expected.Socks.Password {
t.Errorf("Password不匹配: 期望 %s, 实际 %s", tt.expected.Socks.Password, result.Socks.Password)
}
})
}
}