more e2e tests (#1845)

test/e2e/basic/basic.go

@@ -0,0 +1,198 @@
+package basic
+
+import (
+	"fmt"
+	"strings"
+	"time"
+
+	"github.com/fatedier/frp/test/e2e/framework"
+	"github.com/fatedier/frp/test/e2e/framework/consts"
+
+	. "github.com/onsi/ginkgo"
+)
+
+var connTimeout = 2 * time.Second
+
+var _ = Describe("[Feature: Basic]", func() {
+	f := framework.NewDefaultFramework()
+
+	Describe("TCP && UDP", func() {
+		types := []string{"tcp", "udp"}
+		for _, t := range types {
+			proxyType := t
+			It(fmt.Sprintf("Expose a %s echo server", strings.ToUpper(proxyType)), func() {
+				serverConf := consts.DefaultServerConfig
+				clientConf := consts.DefaultClientConfig
+
+				localPortName := ""
+				protocol := "tcp"
+				switch proxyType {
+				case "tcp":
+					localPortName = framework.TCPEchoServerPort
+					protocol = "tcp"
+				case "udp":
+					localPortName = framework.UDPEchoServerPort
+					protocol = "udp"
+				}
+				getProxyConf := func(proxyName string, portName string, extra string) string {
+					return fmt.Sprintf(`
+				[%s]
+				type = %s
+				local_port = {{ .%s }}
+				remote_port = {{ .%s }}
+				`+extra, proxyName, proxyType, localPortName, portName)
+				}
+
+				tests := []struct {
+					proxyName   string
+					portName    string
+					extraConfig string
+				}{
+					{
+						proxyName: "normal",
+						portName:  framework.GenPortName("Normal"),
+					},
+					{
+						proxyName:   "with-encryption",
+						portName:    framework.GenPortName("WithEncryption"),
+						extraConfig: "use_encryption = true",
+					},
+					{
+						proxyName:   "with-compression",
+						portName:    framework.GenPortName("WithCompression"),
+						extraConfig: "use_compression = true",
+					},
+					{
+						proxyName: "with-encryption-and-compression",
+						portName:  framework.GenPortName("WithEncryptionAndCompression"),
+						extraConfig: `
+						use_encryption = true
+						use_compression = true
+						`,
+					},
+				}
+
+				// build all client config
+				for _, test := range tests {
+					clientConf += getProxyConf(test.proxyName, test.portName, test.extraConfig) + "\n"
+				}
+				// run frps and frpc
+				f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+				for _, test := range tests {
+					framework.ExpectRequest(protocol, f.UsedPorts[test.portName],
+						[]byte(consts.TestString), []byte(consts.TestString), connTimeout, test.proxyName)
+				}
+			})
+		}
+	})
+
+	Describe("STCP && SUDP", func() {
+		types := []string{"stcp", "sudp"}
+		for _, t := range types {
+			proxyType := t
+			It(fmt.Sprintf("Expose echo server with %s", strings.ToUpper(proxyType)), func() {
+				serverConf := consts.DefaultServerConfig
+				clientServerConf := consts.DefaultClientConfig
+				clientVisitorConf := consts.DefaultClientConfig
+
+				localPortName := ""
+				protocol := "tcp"
+				switch proxyType {
+				case "stcp":
+					localPortName = framework.TCPEchoServerPort
+					protocol = "tcp"
+				case "sudp":
+					localPortName = framework.UDPEchoServerPort
+					protocol = "udp"
+				}
+
+				correctSK := "abc"
+				wrongSK := "123"
+
+				getProxyServerConf := func(proxyName string, extra string) string {
+					return fmt.Sprintf(`
+				[%s]
+				type = %s
+				role = server
+				sk = %s
+				local_port = {{ .%s }}
+				`+extra, proxyName, proxyType, correctSK, localPortName)
+				}
+				getProxyVisitorConf := func(proxyName string, portName, visitorSK, extra string) string {
+					return fmt.Sprintf(`
+				[%s]
+				type = %s
+				role = visitor
+				server_name = %s
+				sk = %s
+				bind_port = {{ .%s }}
+				`+extra, proxyName, proxyType, proxyName, visitorSK, portName)
+				}
+
+				tests := []struct {
+					proxyName    string
+					bindPortName string
+					visitorSK    string
+					extraConfig  string
+					expectError  bool
+				}{
+					{
+						proxyName:    "normal",
+						bindPortName: framework.GenPortName("Normal"),
+						visitorSK:    correctSK,
+					},
+					{
+						proxyName:    "with-encryption",
+						bindPortName: framework.GenPortName("WithEncryption"),
+						visitorSK:    correctSK,
+						extraConfig:  "use_encryption = true",
+					},
+					{
+						proxyName:    "with-compression",
+						bindPortName: framework.GenPortName("WithCompression"),
+						visitorSK:    correctSK,
+						extraConfig:  "use_compression = true",
+					},
+					{
+						proxyName:    "with-encryption-and-compression",
+						bindPortName: framework.GenPortName("WithEncryptionAndCompression"),
+						visitorSK:    correctSK,
+						extraConfig: `
+						use_encryption = true
+						use_compression = true
+						`,
+					},
+					{
+						proxyName:    "with-error-sk",
+						bindPortName: framework.GenPortName("WithErrorSK"),
+						visitorSK:    wrongSK,
+						expectError:  true,
+					},
+				}
+
+				// build all client config
+				for _, test := range tests {
+					clientServerConf += getProxyServerConf(test.proxyName, test.extraConfig) + "\n"
+				}
+				for _, test := range tests {
+					clientVisitorConf += getProxyVisitorConf(test.proxyName, test.bindPortName, test.visitorSK, test.extraConfig) + "\n"
+				}
+				// run frps and frpc
+				f.RunProcesses([]string{serverConf}, []string{clientServerConf, clientVisitorConf})
+
+				for _, test := range tests {
+					expectResp := []byte(consts.TestString)
+					if test.expectError {
+						framework.ExpectRequestError(protocol, f.UsedPorts[test.bindPortName],
+							[]byte(consts.TestString), connTimeout, test.proxyName)
+						continue
+					}
+
+					framework.ExpectRequest(protocol, f.UsedPorts[test.bindPortName],
+						[]byte(consts.TestString), expectResp, connTimeout, test.proxyName)
+				}
+			})
+		}
+	})
+})

test/e2e/basic/client_server.go

@@ -0,0 +1,95 @@
+package basic
+
+import (
+	"fmt"
+
+	"github.com/fatedier/frp/test/e2e/framework"
+	"github.com/fatedier/frp/test/e2e/framework/consts"
+
+	. "github.com/onsi/ginkgo"
+)
+
+type generalTestConfigures struct {
+	server      string
+	client      string
+	expectError bool
+}
+
+func defineClientServerTest(desc string, f *framework.Framework, configures *generalTestConfigures) {
+	It(desc, func() {
+		serverConf := consts.DefaultServerConfig
+		clientConf := consts.DefaultClientConfig
+
+		serverConf += fmt.Sprintf(`
+				%s
+				`, configures.server)
+
+		clientConf += fmt.Sprintf(`
+				%s
+
+				[tcp]
+				type = tcp
+				local_port = {{ .%s }}
+				remote_port = {{ .%s }}
+
+				[udp]
+				type = udp
+				local_port = {{ .%s }}
+				remote_port = {{ .%s }}
+				`, configures.client,
+			framework.TCPEchoServerPort, framework.GenPortName("TCP"),
+			framework.UDPEchoServerPort, framework.GenPortName("UDP"),
+		)
+
+		f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+		if !configures.expectError {
+			framework.ExpectTCPRequest(f.UsedPorts[framework.GenPortName("TCP")],
+				[]byte(consts.TestString), []byte(consts.TestString), connTimeout, "tcp proxy")
+			framework.ExpectUDPRequest(f.UsedPorts[framework.GenPortName("UDP")],
+				[]byte(consts.TestString), []byte(consts.TestString), connTimeout, "udp proxy")
+		} else {
+			framework.ExpectTCPRequestError(f.UsedPorts[framework.GenPortName("TCP")],
+				[]byte(consts.TestString), connTimeout, "tcp proxy")
+			framework.ExpectUDPRequestError(f.UsedPorts[framework.GenPortName("UDP")],
+				[]byte(consts.TestString), connTimeout, "udp proxy")
+		}
+	})
+}
+
+var _ = Describe("[Feature: Client-Server]", func() {
+	f := framework.NewDefaultFramework()
+
+	Describe("Protocol", func() {
+		supportProtocols := []string{"tcp", "kcp", "websocket"}
+		for _, protocol := range supportProtocols {
+			configures := &generalTestConfigures{
+				server: fmt.Sprintf(`
+				kcp_bind_port = {{ .%s }}
+				protocol = %s"
+				`, consts.PortServerName, protocol),
+				client: "protocol = " + protocol,
+			}
+			defineClientServerTest(protocol, f, configures)
+		}
+	})
+
+	Describe("Authentication", func() {
+		func() {
+			configures := &generalTestConfigures{
+				server: "token = 123456",
+				client: "token = 123456",
+			}
+			defineClientServerTest("Token Correct", f, configures)
+		}()
+
+		func() {
+			configures := &generalTestConfigures{
+				server:      "token = 123456",
+				client:      "token = invalid",
+				expectError: true,
+			}
+			defineClientServerTest("Token Incorrect", f, configures)
+		}()
+	})
+})

test/e2e/e2e.go

@@ -33,7 +33,8 @@ var _ = ginkgo.SynchronizedAfterSuite(func() {
 func RunE2ETests(t *testing.T) {
 	gomega.RegisterFailHandler(framework.Fail)
 
-	log.Info("Starting e2e run %q on Ginkgo node %d", framework.RunID, config.GinkgoConfig.ParallelNode)
+	log.Info("Starting e2e run %q on Ginkgo node %d of total %d",
+		framework.RunID, config.GinkgoConfig.ParallelNode, config.GinkgoConfig.ParallelTotal)
 	ginkgo.RunSpecs(t, "frp e2e suite")
 }
 

test/e2e/e2e_test.go

@@ -8,6 +8,12 @@ import (
 
 	"github.com/fatedier/frp/test/e2e/framework"
 	"github.com/fatedier/frp/utils/log"
+
+	// test source
+	_ "github.com/fatedier/frp/test/e2e/basic"
+	_ "github.com/fatedier/frp/test/e2e/plugin"
+
+	_ "github.com/onsi/ginkgo"
 )
 
 // handleFlags sets up all flags and parses the command line.

test/e2e/examples.go

@@ -10,31 +10,26 @@ import (
 	. "github.com/onsi/ginkgo"
 )
 
-var connTimeout = 5 * time.Second
+var connTimeout = 2 * time.Second
 
 var _ = Describe("[Feature: Example]", func() {
 	f := framework.NewDefaultFramework()
 
 	Describe("TCP", func() {
 		It("Expose a TCP echo server", func() {
-			serverConf := `
-			[common]
-			bind_port = {{ .PortServer }}
-			`
-
-			clientConf := fmt.Sprintf(`
-			[common]
-			server_port = {{ .PortServer }}
+			serverConf := consts.DefaultServerConfig
+			clientConf := consts.DefaultClientConfig
 
+			clientConf += fmt.Sprintf(`
 			[tcp]
 			type = tcp
 			local_port = {{ .%s }}
-			remote_port = {{ .PortTCP }}
-			`, framework.TCPEchoServerPort)
+			remote_port = {{ .%s }}
+			`, framework.TCPEchoServerPort, framework.GenPortName("TCP"))
 
 			f.RunProcesses([]string{serverConf}, []string{clientConf})
 
-			framework.ExpectTCPReuqest(f.UsedPorts["PortTCP"], []byte(consts.TestString), []byte(consts.TestString), connTimeout)
+			framework.ExpectTCPRequest(f.UsedPorts[framework.GenPortName("TCP")], []byte(consts.TestString), []byte(consts.TestString), connTimeout)
 		})
 	})
 })

test/e2e/framework/consts/consts.go

@@ -3,3 +3,19 @@ package consts
 const (
 	TestString = "frp is a fast reverse proxy to help you expose a local server behind a NAT or firewall to the internet."
 )
+
+const (
+	PortServerName = "PortServer"
+)
+
+const (
+	DefaultServerConfig = `
+	[common]
+	bind_port = {{ .PortServer }}
+	`
+
+	DefaultClientConfig = `
+	[common]
+	server_port = {{ .PortServer }}
+	`
+)

test/e2e/framework/framework.go

@@ -60,10 +60,6 @@ func NewFramework(opt Options) *Framework {
 	f := &Framework{
 		portAllocator: port.NewAllocator(opt.FromPortIndex, opt.ToPortIndex, opt.TotalParallelNode, opt.CurrentNodeIndex-1),
 	}
-	f.mockServers = NewMockServers(f.portAllocator)
-	if err := f.mockServers.Run(); err != nil {
-		Failf("%v", err)
-	}
 
 	ginkgo.BeforeEach(f.BeforeEach)
 	ginkgo.AfterEach(f.AfterEach)
@@ -79,6 +75,11 @@ func (f *Framework) BeforeEach() {
 	dir, err := ioutil.TempDir(os.TempDir(), "frpe2e-test-*")
 	ExpectNoError(err)
 	f.TempDirectory = dir
+
+	f.mockServers = NewMockServers(f.portAllocator)
+	if err := f.mockServers.Run(); err != nil {
+		Failf("%v", err)
+	}
 }
 
 func (f *Framework) AfterEach() {
@@ -88,19 +89,38 @@ func (f *Framework) AfterEach() {
 
 	RemoveCleanupAction(f.cleanupHandle)
 
-	os.RemoveAll(f.TempDirectory)
-	f.TempDirectory = ""
-	f.UsedPorts = nil
-	f.serverConfPaths = nil
-	f.clientConfPaths = nil
+	// stop processor
 	for _, p := range f.serverProcesses {
 		p.Stop()
+		if TestContext.Debug {
+			fmt.Println(p.ErrorOutput())
+			fmt.Println(p.StdOutput())
+		}
 	}
 	for _, p := range f.clientProcesses {
 		p.Stop()
+		if TestContext.Debug {
+			fmt.Println(p.ErrorOutput())
+			fmt.Println(p.StdOutput())
+		}
 	}
 	f.serverProcesses = nil
 	f.clientProcesses = nil
+
+	// close mock servers
+	f.mockServers.Close()
+
+	// clean directory
+	os.RemoveAll(f.TempDirectory)
+	f.TempDirectory = ""
+	f.serverConfPaths = nil
+	f.clientConfPaths = nil
+
+	// release used ports
+	for _, port := range f.UsedPorts {
+		f.portAllocator.Release(port)
+	}
+	f.UsedPorts = nil
 }
 
 var portRegex = regexp.MustCompile(`{{ \.Port.*? }}`)

test/e2e/framework/mockservers.go

@@ -1,6 +1,9 @@
 package framework
 
 import (
+	"fmt"
+	"os"
+
 	"github.com/fatedier/frp/test/e2e/mock/echoserver"
 	"github.com/fatedier/frp/test/e2e/pkg/port"
 )
@@ -8,11 +11,13 @@ import (
 const (
 	TCPEchoServerPort = "TCPEchoServerPort"
 	UDPEchoServerPort = "UDPEchoServerPort"
+	UDSEchoServerAddr = "UDSEchoServerAddr"
 )
 
 type MockServers struct {
 	tcpEchoServer *echoserver.Server
 	udpEchoServer *echoserver.Server
+	udsEchoServer *echoserver.Server
 }
 
 func NewMockServers(portAllocator *port.Allocator) *MockServers {
@@ -31,6 +36,15 @@ func NewMockServers(portAllocator *port.Allocator) *MockServers {
 		BindPort:  int32(udpPort),
 		RepeatNum: 1,
 	})
+
+	udsIndex := portAllocator.Get()
+	udsAddr := fmt.Sprintf("%s/frp_echo_server_%d.sock", os.TempDir(), udsIndex)
+	os.Remove(udsAddr)
+	s.udsEchoServer = echoserver.New(echoserver.Options{
+		Type:      echoserver.Unix,
+		BindAddr:  udsAddr,
+		RepeatNum: 1,
+	})
 	return s
 }
 
@@ -41,13 +55,24 @@ func (m *MockServers) Run() error {
 	if err := m.udpEchoServer.Run(); err != nil {
 		return err
 	}
+	if err := m.udsEchoServer.Run(); err != nil {
+		return err
+	}
 	return nil
 }
 
+func (m *MockServers) Close() {
+	m.tcpEchoServer.Close()
+	m.udpEchoServer.Close()
+	m.udsEchoServer.Close()
+	os.Remove(m.udsEchoServer.GetOptions().BindAddr)
+}
+
 func (m *MockServers) GetTemplateParams() map[string]interface{} {
 	ret := make(map[string]interface{})
 	ret[TCPEchoServerPort] = m.tcpEchoServer.GetOptions().BindPort
 	ret[UDPEchoServerPort] = m.udpEchoServer.GetOptions().BindPort
+	ret[UDSEchoServerAddr] = m.udsEchoServer.GetOptions().BindAddr
 	return ret
 }
 

test/e2e/framework/request.go

@@ -6,8 +6,46 @@ import (
 	"github.com/fatedier/frp/test/e2e/pkg/request"
 )
 
-func ExpectTCPReuqest(port int, in, out []byte, timeout time.Duration) {
-	res, err := request.SendTCPRequest(port, in, timeout)
-	ExpectNoError(err)
-	ExpectEqual(string(out), res)
+func ExpectRequest(protocol string, port int, in, out []byte, timeout time.Duration, explain ...interface{}) {
+	switch protocol {
+	case "tcp":
+		ExpectTCPRequest(port, in, out, timeout, explain...)
+	case "udp":
+		ExpectUDPRequest(port, in, out, timeout, explain...)
+	default:
+		Failf("ExpectRequest not support protocol: %s", protocol)
+	}
+}
+
+func ExpectRequestError(protocol string, port int, in []byte, timeout time.Duration, explain ...interface{}) {
+	switch protocol {
+	case "tcp":
+		ExpectTCPRequestError(port, in, timeout, explain...)
+	case "udp":
+		ExpectUDPRequestError(port, in, timeout, explain...)
+	default:
+		Failf("ExpectRequestError not support protocol: %s", protocol)
+	}
+}
+
+func ExpectTCPRequest(port int, in, out []byte, timeout time.Duration, explain ...interface{}) {
+	res, err := request.SendTCPRequest(port, in, timeout)
+	ExpectNoError(err, explain...)
+	ExpectEqual(string(out), res, explain...)
+}
+
+func ExpectTCPRequestError(port int, in []byte, timeout time.Duration, explain ...interface{}) {
+	_, err := request.SendTCPRequest(port, in, timeout)
+	ExpectError(err, explain...)
+}
+
+func ExpectUDPRequest(port int, in, out []byte, timeout time.Duration, explain ...interface{}) {
+	res, err := request.SendUDPRequest(port, in, timeout)
+	ExpectNoError(err, explain...)
+	ExpectEqual(string(out), res, explain...)
+}
+
+func ExpectUDPRequestError(port int, in []byte, timeout time.Duration, explain ...interface{}) {
+	_, err := request.SendUDPRequest(port, in, timeout)
+	ExpectError(err, explain...)
 }

test/e2e/framework/test_context.go

@@ -4,12 +4,15 @@ import (
 	"flag"
 	"fmt"
 	"os"
+
+	"github.com/onsi/ginkgo/config"
 )
 
 type TestContextType struct {
 	FRPClientPath string
 	FRPServerPath string
 	LogLevel      string
+	Debug         bool
 }
 
 var TestContext TestContextType
@@ -23,9 +26,16 @@ var TestContext TestContextType
 // regardless whether the test is actually in the test suite.
 //
 func RegisterCommonFlags(flags *flag.FlagSet) {
+	// Turn on EmitSpecProgress to get spec progress (especially on interrupt)
+	config.GinkgoConfig.EmitSpecProgress = true
+
+	// Randomize specs as well as suites
+	config.GinkgoConfig.RandomizeAllSpecs = true
+
 	flags.StringVar(&TestContext.FRPClientPath, "frpc-path", "../../bin/frpc", "The frp client binary to use.")
 	flags.StringVar(&TestContext.FRPServerPath, "frps-path", "../../bin/frps", "The frp server binary to use.")
 	flags.StringVar(&TestContext.LogLevel, "log-level", "debug", "Log level.")
+	flags.BoolVar(&TestContext.Debug, "debug", false, "Enable debug mode to print detail info.")
 }
 
 func ValidateTestContext(t *TestContextType) error {

test/e2e/framework/util.go

@@ -12,3 +12,7 @@ func init() {
 	uuid, _ := uuid.NewUUID()
 	RunID = uuid.String()
 }
+
+func GenPortName(name string) string {
+	return "Port" + name
+}

test/e2e/pkg/process/process.go

@@ -10,6 +10,7 @@ type Process struct {
 	cmd         *exec.Cmd
 	cancel      context.CancelFunc
 	errorOutput *bytes.Buffer
+	stdOutput   *bytes.Buffer
 
 	beforeStopHandler func()
 }
@@ -22,7 +23,9 @@ func New(path string, params []string) *Process {
 		cancel: cancel,
 	}
 	p.errorOutput = bytes.NewBufferString("")
+	p.stdOutput = bytes.NewBufferString("")
 	cmd.Stderr = p.errorOutput
+	cmd.Stdout = p.stdOutput
 	return p
 }
 
@@ -42,6 +45,10 @@ func (p *Process) ErrorOutput() string {
 	return p.errorOutput.String()
 }
 
+func (p *Process) StdOutput() string {
+	return p.stdOutput.String()
+}
+
 func (p *Process) SetBeforeStopHandler(fn func()) {
 	p.beforeStopHandler = fn
 }

test/e2e/pkg/request/request.go

@@ -6,26 +6,35 @@ import (
 	"time"
 )
 
-func SendTCPRequest(port int, content []byte, timeout time.Duration) (res string, err error) {
+func SendTCPRequest(port int, content []byte, timeout time.Duration) (string, error) {
 	c, err := net.Dial("tcp", fmt.Sprintf("127.0.0.1:%d", port))
 	if err != nil {
-		err = fmt.Errorf("connect to tcp server error: %v", err)
-		return
+		return "", fmt.Errorf("connect to tcp server error: %v", err)
 	}
 	defer c.Close()
 
 	c.SetDeadline(time.Now().Add(timeout))
-	return sendTCPRequestByConn(c, content)
+	return sendRequestByConn(c, content)
 }
 
-func sendTCPRequestByConn(c net.Conn, content []byte) (res string, err error) {
+func SendUDPRequest(port int, content []byte, timeout time.Duration) (string, error) {
+	c, err := net.Dial("udp", fmt.Sprintf("127.0.0.1:%d", port))
+	if err != nil {
+		return "", fmt.Errorf("connect to udp server error:  %v", err)
+	}
+	defer c.Close()
+
+	c.SetDeadline(time.Now().Add(timeout))
+	return sendRequestByConn(c, content)
+}
+
+func sendRequestByConn(c net.Conn, content []byte) (string, error) {
 	c.Write(content)
 
 	buf := make([]byte, 2048)
-	n, errRet := c.Read(buf)
-	if errRet != nil {
-		err = fmt.Errorf("read from tcp error: %v", errRet)
-		return
+	n, err := c.Read(buf)
+	if err != nil {
+		return "", fmt.Errorf("read error: %v", err)
 	}
 	return string(buf[:n]), nil
 }

test/e2e/plugin/client_plugins.go

@@ -0,0 +1,76 @@
+package plugin
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/fatedier/frp/test/e2e/framework"
+	"github.com/fatedier/frp/test/e2e/framework/consts"
+
+	. "github.com/onsi/ginkgo"
+)
+
+var connTimeout = 2 * time.Second
+
+var _ = Describe("[Feature: Client-Plugins]", func() {
+	f := framework.NewDefaultFramework()
+
+	Describe("UnixDomainSocket", func() {
+		It("Expose a unix domain socket echo server", func() {
+			serverConf := consts.DefaultServerConfig
+			clientConf := consts.DefaultClientConfig
+
+			getProxyConf := func(proxyName string, portName string, extra string) string {
+				return fmt.Sprintf(`
+				[%s]
+				type = tcp
+				remote_port = {{ .%s }}
+				plugin = unix_domain_socket
+				plugin_unix_path = {{ .%s }}
+				`+extra, proxyName, portName, framework.UDSEchoServerAddr)
+			}
+
+			tests := []struct {
+				proxyName   string
+				portName    string
+				extraConfig string
+			}{
+				{
+					proxyName: "normal",
+					portName:  framework.GenPortName("Normal"),
+				},
+				{
+					proxyName:   "with-encryption",
+					portName:    framework.GenPortName("WithEncryption"),
+					extraConfig: "use_encryption = true",
+				},
+				{
+					proxyName:   "with-compression",
+					portName:    framework.GenPortName("WithCompression"),
+					extraConfig: "use_compression = true",
+				},
+				{
+					proxyName: "with-encryption-and-compression",
+					portName:  framework.GenPortName("WithEncryptionAndCompression"),
+					extraConfig: `
+					use_encryption = true
+					use_compression = true
+					`,
+				},
+			}
+
+			// build all client config
+			for _, test := range tests {
+				clientConf += getProxyConf(test.proxyName, test.portName, test.extraConfig) + "\n"
+			}
+			// run frps and frpc
+			f.RunProcesses([]string{serverConf}, []string{clientConf})
+
+			for _, test := range tests {
+				framework.ExpectTCPRequest(f.UsedPorts[test.portName],
+					[]byte(consts.TestString), []byte(consts.TestString),
+					connTimeout, test.proxyName)
+			}
+		})
+	})
+})