1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-06-10 09:50:43 +00:00
v2fly/app/router/condition_test.go

363 lines
7.9 KiB
Go
Raw Normal View History

2017-05-08 10:18:13 +00:00
package router_test
import (
"context"
2017-11-06 21:30:56 +00:00
"os"
"path/filepath"
"strconv"
2017-05-08 10:18:13 +00:00
"testing"
2017-11-06 21:30:56 +00:00
proto "github.com/golang/protobuf/proto"
2018-10-22 14:14:00 +00:00
2018-08-02 11:28:13 +00:00
"v2ray.com/core/app/dispatcher"
2017-05-08 10:18:13 +00:00
. "v2ray.com/core/app/router"
2017-11-06 21:30:56 +00:00
"v2ray.com/core/common"
"v2ray.com/core/common/errors"
2017-05-08 10:18:13 +00:00
"v2ray.com/core/common/net"
2017-11-06 21:30:56 +00:00
"v2ray.com/core/common/platform"
2017-05-17 11:28:22 +00:00
"v2ray.com/core/common/protocol"
2018-08-02 11:28:13 +00:00
"v2ray.com/core/common/protocol/http"
2018-10-22 14:14:00 +00:00
"v2ray.com/core/common/session"
2017-11-06 21:30:56 +00:00
"v2ray.com/ext/sysio"
2017-05-08 10:18:13 +00:00
)
func withOutbound(outbound *session.Outbound) context.Context {
return session.ContextWithOutbound(context.Background(), outbound)
}
2018-10-15 06:36:50 +00:00
func withInbound(inbound *session.Inbound) context.Context {
return session.ContextWithInbound(context.Background(), inbound)
}
2017-05-17 11:24:53 +00:00
func TestRoutingRule(t *testing.T) {
type ruleTest struct {
input context.Context
output bool
}
cases := []struct {
rule *RoutingRule
test []ruleTest
}{
{
rule: &RoutingRule{
Domain: []*Domain{
{
Value: "v2ray.com",
Type: Domain_Plain,
},
{
Value: "google.com",
Type: Domain_Domain,
},
2017-05-17 19:46:57 +00:00
{
Value: "^facebook\\.com$",
Type: Domain_Regex,
},
2017-05-17 11:24:53 +00:00
},
},
test: []ruleTest{
2017-12-03 00:04:38 +00:00
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.DomainAddress("v2ray.com"), 80)}),
2017-05-17 11:24:53 +00:00
output: true,
},
2017-12-03 00:04:38 +00:00
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.DomainAddress("www.v2ray.com.www"), 80)}),
2017-05-17 11:24:53 +00:00
output: true,
},
2017-12-03 00:04:38 +00:00
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.DomainAddress("v2ray.co"), 80)}),
2017-05-17 11:24:53 +00:00
output: false,
},
2017-12-03 00:04:38 +00:00
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.DomainAddress("www.google.com"), 80)}),
2017-05-17 11:24:53 +00:00
output: true,
},
2017-12-03 00:04:38 +00:00
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.DomainAddress("facebook.com"), 80)}),
2017-05-17 19:46:57 +00:00
output: true,
},
2017-12-03 00:04:38 +00:00
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.DomainAddress("www.facebook.com"), 80)}),
2017-05-17 19:46:57 +00:00
output: false,
},
2017-12-03 00:04:38 +00:00
{
2017-05-17 19:46:57 +00:00
input: context.Background(),
output: false,
},
2017-05-17 11:24:53 +00:00
},
},
{
rule: &RoutingRule{
Cidr: []*CIDR{
{
Ip: []byte{8, 8, 8, 8},
Prefix: 32,
},
{
Ip: []byte{8, 8, 8, 8},
Prefix: 32,
},
{
Ip: net.ParseAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334").IP(),
Prefix: 128,
},
},
},
test: []ruleTest{
2017-12-03 00:04:38 +00:00
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.ParseAddress("8.8.8.8"), 80)}),
2017-05-17 11:24:53 +00:00
output: true,
},
2017-12-03 00:04:38 +00:00
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.ParseAddress("8.8.4.4"), 80)}),
2017-05-17 11:24:53 +00:00
output: false,
},
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.ParseAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), 80)}),
output: true,
},
{
input: context.Background(),
output: false,
},
},
},
{
rule: &RoutingRule{
Geoip: []*GeoIP{
{
Cidr: []*CIDR{
{
Ip: []byte{8, 8, 8, 8},
Prefix: 32,
},
{
Ip: []byte{8, 8, 8, 8},
Prefix: 32,
},
{
Ip: net.ParseAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334").IP(),
Prefix: 128,
},
},
},
},
},
test: []ruleTest{
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.ParseAddress("8.8.8.8"), 80)}),
output: true,
},
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.ParseAddress("8.8.4.4"), 80)}),
output: false,
},
2017-12-03 00:04:38 +00:00
{
input: withOutbound(&session.Outbound{Target: net.TCPDestination(net.ParseAddress("2001:0db8:85a3:0000:0000:8a2e:0370:7334"), 80)}),
2017-05-17 11:24:53 +00:00
output: true,
},
2017-12-03 00:04:38 +00:00
{
2017-05-17 19:46:57 +00:00
input: context.Background(),
output: false,
},
2017-05-17 11:24:53 +00:00
},
},
2018-10-22 18:59:01 +00:00
{
rule: &RoutingRule{
SourceCidr: []*CIDR{
{
Ip: []byte{192, 168, 0, 0},
Prefix: 16,
},
},
},
test: []ruleTest{
{
input: withInbound(&session.Inbound{Source: net.TCPDestination(net.ParseAddress("192.168.0.1"), 80)}),
output: true,
},
{
input: withInbound(&session.Inbound{Source: net.TCPDestination(net.ParseAddress("10.0.0.1"), 80)}),
output: false,
},
},
},
2017-05-17 11:28:22 +00:00
{
rule: &RoutingRule{
UserEmail: []string{
"admin@v2ray.com",
},
},
test: []ruleTest{
2017-12-03 00:04:38 +00:00
{
2018-10-15 06:36:50 +00:00
input: withInbound(&session.Inbound{User: &protocol.MemoryUser{Email: "admin@v2ray.com"}}),
2017-05-17 11:28:22 +00:00
output: true,
},
2017-12-03 00:04:38 +00:00
{
2018-10-15 06:36:50 +00:00
input: withInbound(&session.Inbound{User: &protocol.MemoryUser{Email: "love@v2ray.com"}}),
2017-05-17 11:28:22 +00:00
output: false,
},
2017-12-03 00:04:38 +00:00
{
2017-05-17 19:46:57 +00:00
input: context.Background(),
output: false,
},
2017-05-17 11:28:22 +00:00
},
},
2018-08-02 11:28:13 +00:00
{
rule: &RoutingRule{
Protocol: []string{"http"},
},
test: []ruleTest{
{
input: dispatcher.ContextWithSniffingResult(context.Background(), &http.SniffHeader{}),
output: true,
},
},
},
2018-10-22 18:59:01 +00:00
{
rule: &RoutingRule{
InboundTag: []string{"test", "test1"},
},
test: []ruleTest{
{
input: withInbound(&session.Inbound{Tag: "test"}),
output: true,
},
{
input: withInbound(&session.Inbound{Tag: "test2"}),
output: false,
},
},
},
2017-05-17 11:24:53 +00:00
}
for _, test := range cases {
cond, err := test.rule.BuildCondition()
2018-10-22 18:59:01 +00:00
common.Must(err)
2017-05-17 11:24:53 +00:00
2018-10-22 18:59:01 +00:00
for _, subtest := range test.test {
actual := cond.Apply(subtest.input)
if actual != subtest.output {
t.Error("test case failed: ", subtest.input, " expected ", subtest.output, " but got ", actual)
}
2017-05-17 11:24:53 +00:00
}
}
}
2017-11-06 21:30:56 +00:00
func loadGeoSite(country string) ([]*Domain, error) {
geositeBytes, err := sysio.ReadAsset("geosite.dat")
if err != nil {
return nil, err
}
var geositeList GeoSiteList
if err := proto.Unmarshal(geositeBytes, &geositeList); err != nil {
return nil, err
}
for _, site := range geositeList.Entry {
if site.CountryCode == country {
return site.Domain, nil
}
}
return nil, errors.New("country not found: " + country)
}
func TestChinaSites(t *testing.T) {
2017-12-25 20:54:44 +00:00
common.Must(sysio.CopyFile(platform.GetAssetLocation("geosite.dat"), filepath.Join(os.Getenv("GOPATH"), "src", "v2ray.com", "core", "release", "config", "geosite.dat")))
2017-11-06 21:30:56 +00:00
domains, err := loadGeoSite("CN")
2019-01-31 19:57:01 +00:00
common.Must(err)
2017-11-06 21:30:56 +00:00
2018-08-19 20:28:02 +00:00
matcher, err := NewDomainMatcher(domains)
2018-08-19 19:04:15 +00:00
common.Must(err)
2017-11-06 21:30:56 +00:00
2019-01-31 19:57:01 +00:00
type TestCase struct {
Domain string
Output bool
}
testCases := []TestCase{
{
Domain: "163.com",
Output: true,
},
{
Domain: "163.com",
Output: true,
},
{
Domain: "164.com",
Output: false,
},
{
Domain: "164.com",
Output: false,
},
}
2017-11-06 21:30:56 +00:00
for i := 0; i < 1024; i++ {
2019-01-31 19:57:01 +00:00
testCases = append(testCases, TestCase{Domain: strconv.Itoa(i) + ".not-exists.com", Output: false})
}
for _, testCase := range testCases {
r := matcher.ApplyDomain(testCase.Domain)
if r != testCase.Output {
t.Error("expected output ", testCase.Output, " for domain ", testCase.Domain, " but got ", r)
}
2017-11-06 21:30:56 +00:00
}
}
2018-11-07 22:57:06 +00:00
func BenchmarkMultiGeoIPMatcher(b *testing.B) {
common.Must(sysio.CopyFile(platform.GetAssetLocation("geoip.dat"), filepath.Join(os.Getenv("GOPATH"), "src", "v2ray.com", "core", "release", "config", "geoip.dat")))
var geoips []*GeoIP
{
ips, err := loadGeoIP("CN")
common.Must(err)
geoips = append(geoips, &GeoIP{
CountryCode: "CN",
Cidr: ips,
})
}
{
ips, err := loadGeoIP("JP")
common.Must(err)
geoips = append(geoips, &GeoIP{
CountryCode: "JP",
Cidr: ips,
})
}
{
ips, err := loadGeoIP("CA")
common.Must(err)
geoips = append(geoips, &GeoIP{
CountryCode: "CA",
Cidr: ips,
})
}
{
ips, err := loadGeoIP("US")
common.Must(err)
geoips = append(geoips, &GeoIP{
CountryCode: "US",
Cidr: ips,
})
}
matcher, err := NewMultiGeoIPMatcher(geoips, false)
common.Must(err)
ctx := withOutbound(&session.Outbound{Target: net.TCPDestination(net.ParseAddress("8.8.8.8"), 80)})
b.ResetTimer()
for i := 0; i < b.N; i++ {
_ = matcher.Apply(ctx)
}
}