lzhr
/
v2fly
mirror of https://github.com/v2fly/v2ray-core.git
1
0
Fork 0
Code Issues Releases Wiki Activity

update test for router refactor

This commit is contained in:
Shelikhoo 2021-09-07 13:43:28 +01:00
parent 3c56a7f947
commit 98ee44befd
No known key found for this signature in database
GPG Key ID: C4D5E79D22B25316
11 changed files with 96 additions and 88 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

36
app/dns/dns_test.go
View File

@ -1,6 +1,7 @@
package dns_test
import (
"github.com/v2fly/v2ray-core/v4/app/router/routercommon"
"google.golang.org/protobuf/types/known/anypb"
"testing"
"time"
@ -14,7 +15,6 @@ import (
"github.com/v2fly/v2ray-core/v4/app/policy"
"github.com/v2fly/v2ray-core/v4/app/proxyman"
_ "github.com/v2fly/v2ray-core/v4/app/proxyman/outbound"
"github.com/v2fly/v2ray-core/v4/app/router"
"github.com/v2fly/v2ray-core/v4/common"
"github.com/v2fly/v2ray-core/v4/common/net"
"github.com/v2fly/v2ray-core/v4/common/serial"
@ -430,7 +430,7 @@ func TestStaticHostDomain(t *testing.T) {
Port: uint32(port),
},
},
StaticHosts: []*Config_HostMapping{
StaticHosts: []*HostMapping{
{
Type: DomainMatchingType_Full,
Domain: "example.com",
@ -496,10 +496,10 @@ func TestIPMatch(t *testing.T) {
},
Port: uint32(port),
},
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{
CountryCode: "local",
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{
// inner ip, will not match
Ip: []byte{192, 168, 11, 1},
@ -520,10 +520,10 @@ func TestIPMatch(t *testing.T) {
},
Port: uint32(port),
},
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{
CountryCode: "test",
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{8, 8, 8, 8},
Prefix: 32,
@ -532,7 +532,7 @@ func TestIPMatch(t *testing.T) {
},
{
CountryCode: "test",
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{8, 8, 8, 4},
Prefix: 32,
@ -620,10 +620,10 @@ func TestLocalDomain(t *testing.T) {
// Equivalent of dotless:localhost
{Type: DomainMatchingType_Regex, Domain: "^[^.]*localhost[^.]*$"},
},
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{ // Will match localhost, localhost-a and localhost-b,
CountryCode: "local",
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{Ip: []byte{127, 0, 0, 2}, Prefix: 32},
{Ip: []byte{127, 0, 0, 3}, Prefix: 32},
{Ip: []byte{127, 0, 0, 4}, Prefix: 32},
@ -649,7 +649,7 @@ func TestLocalDomain(t *testing.T) {
},
},
},
StaticHosts: []*Config_HostMapping{
StaticHosts: []*HostMapping{
{
Type: DomainMatchingType_Full,
Domain: "hostnamestatic",
@ -818,9 +818,9 @@ func TestMultiMatchPrioritizedDomain(t *testing.T) {
Domain: "google.com",
},
},
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{ // Will only match 8.8.8.8 and 8.8.4.4
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{Ip: []byte{8, 8, 8, 8}, Prefix: 32},
{Ip: []byte{8, 8, 4, 4}, Prefix: 32},
},
@ -843,9 +843,9 @@ func TestMultiMatchPrioritizedDomain(t *testing.T) {
Domain: "google.com",
},
},
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{ // Will match 8.8.8.8 and 8.8.8.7, etc
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{Ip: []byte{8, 8, 8, 7}, Prefix: 24},
},
},
@ -867,9 +867,9 @@ func TestMultiMatchPrioritizedDomain(t *testing.T) {
Domain: "api.google.com",
},
},
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{ // Will only match 8.8.7.7 (api.google.com)
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{Ip: []byte{8, 8, 7, 7}, Prefix: 32},
},
},
@ -891,9 +891,9 @@ func TestMultiMatchPrioritizedDomain(t *testing.T) {
Domain: "v2.api.google.com",
},
},
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{ // Will only match 8.8.7.8 (v2.api.google.com)
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{Ip: []byte{8, 8, 7, 8}, Prefix: 32},
},
},

2
app/dns/hosts_test.go
View File

@ -12,7 +12,7 @@ import (
)
func TestStaticHosts(t *testing.T) {
pb := []*Config_HostMapping{
pb := []*HostMapping{
{
Type: DomainMatchingType_Full,
Domain: "v2fly.org",

5
app/router/command/command_test.go
View File

@ -2,6 +2,7 @@ package command_test
import (
"context"
"github.com/v2fly/v2ray-core/v4/app/router/routercommon"
"testing"
"time"
@ -232,11 +233,11 @@ func TestSerivceTestRoute(t *testing.T) {
TargetTag: &router.RoutingRule_Tag{Tag: "out"},
},
{
Domain: []*router.Domain{{Type: router.Domain_RootDomain, Value: "com"}},
Domain: []*routercommon.Domain{{Type: routercommon.Domain_RootDomain, Value: "com"}},
TargetTag: &router.RoutingRule_Tag{Tag: "out"},
},
{
SourceGeoip: []*router.GeoIP{{CountryCode: "private", Cidr: []*router.CIDR{{Ip: []byte{127, 0, 0, 0}, Prefix: 8}}}},
SourceGeoip: []*routercommon.GeoIP{{CountryCode: "private", Cidr: []*routercommon.CIDR{{Ip: []byte{127, 0, 0, 0}, Prefix: 8}}}},
TargetTag: &router.RoutingRule_Tag{Tag: "out"},
},
{

11
app/router/condition_geoip_test.go
View File

@ -2,6 +2,7 @@ package router_test
import (
"errors"
"github.com/v2fly/v2ray-core/v4/app/router/routercommon"
"io/fs"
"os"
"path/filepath"
@ -38,17 +39,17 @@ func init() {
func TestGeoIPMatcherContainer(t *testing.T) {
container := &router.GeoIPMatcherContainer{}
m1, err := container.Add(&router.GeoIP{
m1, err := container.Add(&routercommon.GeoIP{
CountryCode: "CN",
})
common.Must(err)
m2, err := container.Add(&router.GeoIP{
m2, err := container.Add(&routercommon.GeoIP{
CountryCode: "US",
})
common.Must(err)
m3, err := container.Add(&router.GeoIP{
m3, err := container.Add(&routercommon.GeoIP{
CountryCode: "CN",
})
common.Must(err)
@ -194,12 +195,12 @@ func TestGeoIPMatcher6US(t *testing.T) {
}
}
func loadGeoIP(country string) ([]*router.CIDR, error) {
func loadGeoIP(country string) ([]*routercommon.CIDR, error) {
geoipBytes, err := filesystem.ReadAsset("geoip.dat")
if err != nil {
return nil, err
}
var geoipList router.GeoIPList
var geoipList routercommon.GeoIPList
if err := proto.Unmarshal(geoipBytes, &geoipList); err != nil {
return nil, err
}

31
app/router/condition_test.go
View File

@ -2,6 +2,7 @@ package router_test
import (
"errors"
"github.com/v2fly/v2ray-core/v4/app/router/routercommon"
"io/fs"
"os"
"path/filepath"
@ -79,18 +80,18 @@ func TestRoutingRule(t *testing.T) {
}{
{
rule: &router.RoutingRule{
Domain: []*router.Domain{
Domain: []*routercommon.Domain{
{
Value: "v2fly.org",
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
},
{
Value: "google.com",
Type: router.Domain_RootDomain,
Type: routercommon.Domain_RootDomain,
},
{
Value: "^facebook\\.com$",
Type: router.Domain_Regex,
Type: routercommon.Domain_Regex,
},
},
},
@ -127,7 +128,7 @@ func TestRoutingRule(t *testing.T) {
},
{
rule: &router.RoutingRule{
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{8, 8, 8, 8},
Prefix: 32,
@ -163,9 +164,9 @@ func TestRoutingRule(t *testing.T) {
},
{
rule: &router.RoutingRule{
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{8, 8, 8, 8},
Prefix: 32,
@ -203,7 +204,7 @@ func TestRoutingRule(t *testing.T) {
},
{
rule: &router.RoutingRule{
SourceCidr: []*router.CIDR{
SourceCidr: []*routercommon.CIDR{
{
Ip: []byte{192, 168, 0, 0},
Prefix: 16,
@ -351,12 +352,12 @@ func TestRoutingRule(t *testing.T) {
}
}
func loadGeoSite(country string) ([]*router.Domain, error) {
func loadGeoSite(country string) ([]*routercommon.Domain, error) {
geositeBytes, err := filesystem.ReadAsset("geosite.dat")
if err != nil {
return nil, err
}
var geositeList router.GeoSiteList
var geositeList routercommon.GeoSiteList
if err := proto.Unmarshal(geositeBytes, &geositeList); err != nil {
return nil, err
}
@ -502,12 +503,12 @@ func BenchmarkDomainMatcher(b *testing.B) {
}
func BenchmarkMultiGeoIPMatcher(b *testing.B) {
var geoips []*router.GeoIP
var geoips []*routercommon.GeoIP
{
ips, err := loadGeoIP("CN")
common.Must(err)
geoips = append(geoips, &router.GeoIP{
geoips = append(geoips, &routercommon.GeoIP{
CountryCode: "CN",
Cidr: ips,
})
@ -516,7 +517,7 @@ func BenchmarkMultiGeoIPMatcher(b *testing.B) {
{
ips, err := loadGeoIP("JP")
common.Must(err)
geoips = append(geoips, &router.GeoIP{
geoips = append(geoips, &routercommon.GeoIP{
CountryCode: "JP",
Cidr: ips,
})
@ -525,7 +526,7 @@ func BenchmarkMultiGeoIPMatcher(b *testing.B) {
{
ips, err := loadGeoIP("CA")
common.Must(err)
geoips = append(geoips, &router.GeoIP{
geoips = append(geoips, &routercommon.GeoIP{
CountryCode: "CA",
Cidr: ips,
})
@ -534,7 +535,7 @@ func BenchmarkMultiGeoIPMatcher(b *testing.B) {
{
ips, err := loadGeoIP("US")
common.Must(err)
geoips = append(geoips, &router.GeoIP{
geoips = append(geoips, &routercommon.GeoIP{
CountryCode: "US",
Cidr: ips,
})

13
app/router/router_test.go
View File

@ -2,6 +2,7 @@ package router_test
import (
"context"
"github.com/v2fly/v2ray-core/v4/app/router/routercommon"
"testing"
"github.com/golang/mock/gomock"
@ -145,13 +146,13 @@ func TestLeastLoadBalancer(t *testing.T) {
func TestIPOnDemand(t *testing.T) {
config := &Config{
DomainStrategy: Config_IpOnDemand,
DomainStrategy: DomainStrategy_IpOnDemand,
Rule: []*RoutingRule{
{
TargetTag: &RoutingRule_Tag{
Tag: "test",
},
Cidr: []*CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{192, 168, 0, 0},
Prefix: 16,
@ -180,13 +181,13 @@ func TestIPOnDemand(t *testing.T) {
func TestIPIfNonMatchDomain(t *testing.T) {
config := &Config{
DomainStrategy: Config_IpIfNonMatch,
DomainStrategy: DomainStrategy_IpIfNonMatch,
Rule: []*RoutingRule{
{
TargetTag: &RoutingRule_Tag{
Tag: "test",
},
Cidr: []*CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{192, 168, 0, 0},
Prefix: 16,
@ -215,13 +216,13 @@ func TestIPIfNonMatchDomain(t *testing.T) {
func TestIPIfNonMatchIP(t *testing.T) {
config := &Config{
DomainStrategy: Config_IpIfNonMatch,
DomainStrategy: DomainStrategy_IpIfNonMatch,
Rule: []*RoutingRule{
{
TargetTag: &RoutingRule_Tag{
Tag: "test",
},
Cidr: []*CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{127, 0, 0, 0},
Prefix: 8,

2
infra/conf/synthetic/dns/dns_test.go
View File

@ -112,7 +112,7 @@ func TestDNSConfigParsing(t *testing.T) {
},
},
},
StaticHosts: []*dns.Config_HostMapping{
StaticHosts: []*dns.HostMapping{
{
Type: dns.DomainMatchingType_Subdomain,
Domain: "example.com",

55
infra/conf/synthetic/router/router_test.go
View File

@ -2,6 +2,7 @@ package router_test
import (
"encoding/json"
"github.com/v2fly/v2ray-core/v4/app/router/routercommon"
"github.com/v2fly/v2ray-core/v4/infra/conf/cfgcommon/testassist"
router2 "github.com/v2fly/v2ray-core/v4/infra/conf/synthetic/router"
"testing"
@ -108,7 +109,7 @@ func TestRouterConfig(t *testing.T) {
}`,
Parser: createParser(),
Output: &router.Config{
DomainStrategy: router.Config_AsIs,
DomainStrategy: router.DomainStrategy_AsIs,
BalancingRule: []*router.BalancingRule{
{
Tag: "b1",
@ -140,13 +141,13 @@ func TestRouterConfig(t *testing.T) {
},
Rule: []*router.RoutingRule{
{
Domain: []*router.Domain{
Domain: []*routercommon.Domain{
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "baidu.com",
},
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "qq.com",
},
},
@ -155,13 +156,13 @@ func TestRouterConfig(t *testing.T) {
},
},
{
Domain: []*router.Domain{
Domain: []*routercommon.Domain{
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "v2fly.org",
},
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "github.com",
},
},
@ -170,9 +171,9 @@ func TestRouterConfig(t *testing.T) {
},
},
{
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{10, 0, 0, 0},
Prefix: 8,
@ -248,16 +249,16 @@ func TestRouterConfig(t *testing.T) {
}`,
Parser: createParser(),
Output: &router.Config{
DomainStrategy: router.Config_IpIfNonMatch,
DomainStrategy: router.DomainStrategy_IpIfNonMatch,
Rule: []*router.RoutingRule{
{
Domain: []*router.Domain{
Domain: []*routercommon.Domain{
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "baidu.com",
},
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "qq.com",
},
},
@ -266,13 +267,13 @@ func TestRouterConfig(t *testing.T) {
},
},
{
Domain: []*router.Domain{
Domain: []*routercommon.Domain{
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "v2fly.org",
},
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "github.com",
},
},
@ -281,9 +282,9 @@ func TestRouterConfig(t *testing.T) {
},
},
{
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{10, 0, 0, 0},
Prefix: 8,
@ -334,16 +335,16 @@ func TestRouterConfig(t *testing.T) {
}`,
Parser: createParser(),
Output: &router.Config{
DomainStrategy: router.Config_AsIs,
DomainStrategy: router.DomainStrategy_AsIs,
Rule: []*router.RoutingRule{
{
Domain: []*router.Domain{
Domain: []*routercommon.Domain{
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "baidu.com",
},
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "qq.com",
},
},
@ -352,13 +353,13 @@ func TestRouterConfig(t *testing.T) {
},
},
{
Domain: []*router.Domain{
Domain: []*routercommon.Domain{
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "v2fly.org",
},
{
Type: router.Domain_Plain,
Type: routercommon.Domain_Plain,
Value: "github.com",
},
},
@ -367,9 +368,9 @@ func TestRouterConfig(t *testing.T) {
},
},
{
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{10, 0, 0, 0},
Prefix: 8,

7
infra/conf/v4/v2ray_test.go
View File

@ -2,6 +2,7 @@ package v4_test
import (
"encoding/json"
"github.com/v2fly/v2ray-core/v4/app/router/routercommon"
"github.com/v2fly/v2ray-core/v4/infra/conf/cfgcommon/muxcfg"
"github.com/v2fly/v2ray-core/v4/infra/conf/cfgcommon/testassist"
"github.com/v2fly/v2ray-core/v4/infra/conf/v4"
@ -158,12 +159,12 @@ func TestV2RayConfig(t *testing.T) {
serial.ToTypedMessage(&proxyman.InboundConfig{}),
serial.ToTypedMessage(&proxyman.OutboundConfig{}),
serial.ToTypedMessage(&router.Config{
DomainStrategy: router.Config_AsIs,
DomainStrategy: router.DomainStrategy_AsIs,
Rule: []*router.RoutingRule{
{
Geoip: []*router.GeoIP{
Geoip: []*routercommon.GeoIP{
{
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{10, 0, 0, 0},
Prefix: 8,

5
testing/scenarios/dns_test.go
View File

@ -2,6 +2,7 @@ package scenarios
import (
"fmt"
"github.com/v2fly/v2ray-core/v4/app/router/routercommon"
"google.golang.org/protobuf/types/known/anypb"
"testing"
"time"
@ -38,10 +39,10 @@ func TestResolveIP(t *testing.T) {
},
}),
serial.ToTypedMessage(&router.Config{
DomainStrategy: router.Config_IpIfNonMatch,
DomainStrategy: router.DomainStrategy_IpIfNonMatch,
Rule: []*router.RoutingRule{
{
Cidr: []*router.CIDR{
Cidr: []*routercommon.CIDR{
{
Ip: []byte{127, 0, 0, 0},
Prefix: 8,

17
testing/scenarios/reverse_test.go
View File

@ -1,6 +1,7 @@
package scenarios
import (
"github.com/v2fly/v2ray-core/v4/app/router/routercommon"
"google.golang.org/protobuf/types/known/anypb"
"testing"
"time"
@ -54,8 +55,8 @@ func TestReverseProxy(t *testing.T) {
serial.ToTypedMessage(&router.Config{
Rule: []*router.RoutingRule{
{
Domain: []*router.Domain{
{Type: router.Domain_Full, Value: "test.v2fly.org"},
Domain: []*routercommon.Domain{
{Type: routercommon.Domain_Full, Value: "test.v2fly.org"},
},
TargetTag: &router.RoutingRule_Tag{
Tag: "portal",
@ -123,8 +124,8 @@ func TestReverseProxy(t *testing.T) {
serial.ToTypedMessage(&router.Config{
Rule: []*router.RoutingRule{
{
Domain: []*router.Domain{
{Type: router.Domain_Full, Value: "test.v2fly.org"},
Domain: []*routercommon.Domain{
{Type: routercommon.Domain_Full, Value: "test.v2fly.org"},
},
TargetTag: &router.RoutingRule_Tag{
Tag: "reverse",
@ -239,8 +240,8 @@ func TestReverseProxyLongRunning(t *testing.T) {
serial.ToTypedMessage(&router.Config{
Rule: []*router.RoutingRule{
{
Domain: []*router.Domain{
{Type: router.Domain_Full, Value: "test.v2fly.org"},
Domain: []*routercommon.Domain{
{Type: routercommon.Domain_Full, Value: "test.v2fly.org"},
},
TargetTag: &router.RoutingRule_Tag{
Tag: "portal",
@ -322,8 +323,8 @@ func TestReverseProxyLongRunning(t *testing.T) {
serial.ToTypedMessage(&router.Config{
Rule: []*router.RoutingRule{
{
Domain: []*router.Domain{
{Type: router.Domain_Full, Value: "test.v2fly.org"},
Domain: []*routercommon.Domain{
{Type: routercommon.Domain_Full, Value: "test.v2fly.org"},
},
TargetTag: &router.RoutingRule_Tag{
Tag: "reverse",