func TestMultipleLatencyRequest(t *testing.T) {
tt, err := tunneltest.Serve(singleHTTP(handlerLatencyEchoHTTP))
if err != nil {
t.Fatal(err)
}
defer tt.Close()
// make a request to tunnelserver, this should be tunneled to local server
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
msg := "hello" + strconv.Itoa(i)
res, err := echoHTTP(tt, msg)
if err != nil {
t.Fatalf("echoHTTP error: %s", err)
}
if res != msg {
t.Errorf("got %q, want %q", res, msg)
}
}(i)
}
wg.Wait()
}
func TestReconnectClient(t *testing.T) {
tt, err := tunneltest.Serve(singleHTTP(handlerEchoHTTP))
if err != nil {
t.Fatal(err)
}
defer tt.Close()
msg := "hello"
res, err := echoHTTP(tt, msg)
if err != nil {
t.Fatalf("echoHTTP error: %s", err)
}
if res != msg {
t.Errorf("got %q, want %q", res, msg)
}
client := tt.Clients["http"]
// close client, and start it again
client.Close()
go client.Start()
<-client.StartNotify()
msg = "helloagain"
res, err = echoHTTP(tt, msg)
if err != nil {
t.Fatalf("echoHTTP error: %s", err)
}
if res != msg {
t.Errorf("got %q, want %q", res, msg)
}
}
func TestMultipleLatencyTCP(t *testing.T) {
tt, err := tunneltest.Serve(singleTCP(handlerLatencyEchoTCP))
if err != nil {
t.Fatal(err)
}
defer tt.Close()
var wg sync.WaitGroup
for i := 0; i < 100; i++ {
wg.Add(1)
go func(i int) {
defer wg.Done()
msg := "hello" + strconv.Itoa(i)
res, err := echoTCP(tt, msg)
if err != nil {
t.Errorf("echoTCP: %s", err)
}
if res != msg {
t.Errorf("got %q, want %q", res, msg)
}
}(i)
}
wg.Wait()
}
func TestLatencyWebsocket(t *testing.T) {
tt, err := tunneltest.Serve(singleHTTP(testHandler(t, handlerEchoWS(sleep))))
if err != nil {
t.Fatal(err)
}
testWebsocket("handlerLatencyEchoWS", 20, t, tt)
}
func TestWebsocket(t *testing.T) {
tt, err := tunneltest.Serve(singleHTTP(testHandler(t, handlerEchoWS(nil))))
if err != nil {
t.Fatal(err)
}
testWebsocket("handlerEchoWS", 100, t, tt)
}
func TestNoClient(t *testing.T) {
const expectedErr = "no client session established"
rec := tunneltest.NewStateRecorder()
tt, err := tunneltest.Serve(singleRecHTTP(handlerEchoHTTP, rec.C()))
if err != nil {
t.Fatal(err)
}
defer tt.Close()
if err := rec.WaitTransitions(
tunnel.ClientStarted,
tunnel.ClientConnecting,
tunnel.ClientConnected,
); err != nil {
t.Fatal(err)
}
if err := tt.ServerStateRecorder.WaitTransition(
tunnel.ClientUnknown,
tunnel.ClientConnected,
); err != nil {
t.Fatal(err)
}
// close client, this is the main point of the test
if err := tt.Clients["http"].Close(); err != nil {
t.Fatal(err)
}
if err := rec.WaitTransitions(
tunnel.ClientConnected,
tunnel.ClientDisconnected,
tunnel.ClientClosed,
); err != nil {
t.Fatal(err)
}
if err := tt.ServerStateRecorder.WaitTransition(
tunnel.ClientConnected,
tunnel.ClientClosed,
); err != nil {
t.Fatal(err)
}
msg := "hello"
res, err := echoHTTP(tt, msg)
if err != nil {
t.Fatalf("echoHTTP error: %s", err)
}
if res != expectedErr {
t.Errorf("got %q, want %q", res, msg)
}
}
func TestSingleTCP(t *testing.T) {
tt, err := tunneltest.Serve(singleTCP(handlerEchoTCP))
if err != nil {
t.Fatal(err)
}
defer tt.Close()
msg := "hello"
res, err := echoTCP(tt, msg)
if err != nil {
t.Fatalf("echoTCP error: %s", err)
}
if msg != res {
t.Errorf("got %q, want %q", res, msg)
}
}
func TestSingleLatencyRequest(t *testing.T) {
tt, err := tunneltest.Serve(singleHTTP(handlerLatencyEchoHTTP))
if err != nil {
t.Fatal(err)
}
defer tt.Close()
msg := "hello"
res, err := echoHTTP(tt, msg)
if err != nil {
t.Fatalf("echoHTTP error: %s", err)
}
if res != msg {
t.Errorf("got %q, want %q", res, msg)
}
}
func TestNoLocalServer(t *testing.T) {
const expectedErr = "no local server"
tt, err := tunneltest.Serve(singleHTTP(handlerEchoHTTP))
if err != nil {
t.Fatal(err)
}
defer tt.Close()
// close local listener, this is the main point of the test
tt.Listeners["http"][0].Close()
msg := "hello"
res, err := echoHTTP(tt, msg)
if err != nil {
t.Fatalf("echoHTTP error: %s", err)
}
if res != expectedErr {
t.Errorf("got %q, want %q", res, msg)
}
}
func TestNoHost(t *testing.T) {
tt, err := tunneltest.Serve(singleHTTP(handlerEchoHTTP))
if err != nil {
t.Fatal(err)
}
defer tt.Close()
noBackoff := backoff.NewConstantBackOff(time.Duration(-1))
unknown, err := tunnel.NewClient(&tunnel.ClientConfig{
Identifier: "unknown",
ServerAddr: tt.ServerAddr().String(),
Backoff: noBackoff,
Debug: testing.Verbose(),
})
if err != nil {
t.Fatalf("client error: %s", err)
}
unknown.Start()
defer unknown.Close()
if err := tt.ServerStateRecorder.WaitTransition(
tunnel.ClientUnknown,
tunnel.ClientClosed,
); err != nil {
t.Fatal(err)
}
unknown.Start()
if err := tt.ServerStateRecorder.WaitTransition(
tunnel.ClientClosed,
tunnel.ClientClosed,
); err != nil {
t.Fatal(err)
}
}
func TestMultipleStreamTCP(t *testing.T) {
tunnels := map[string]*tunneltest.Tunnel{
"http": {
Type: tunneltest.TypeHTTP,
LocalAddr: "127.0.0.1:0",
Handler: handlerEchoHTTP,
},
"tcp": {
Type: tunneltest.TypeTCP,
ClientIdent: "http",
LocalAddr: "127.0.0.1:0",
RemoteAddr: "127.0.0.1:0",
Handler: handlerEchoTCP,
},
"tcp_all": {
Type: tunneltest.TypeTCP,
ClientIdent: "http",
LocalAddr: "127.0.0.1:0",
RemoteAddr: "0.0.0.0:0",
Handler: handlerEchoTCP,
},
}
addrs, err := tunneltest.UsableAddrs()
if err != nil {
t.Fatal(err)
}
clients := []string{"tcp"}
for i, addr := range addrs {
if addr.IP.IsLoopback() {
continue
}
client := fmt.Sprintf("tcp_%d", i)
tunnels[client] = &tunneltest.Tunnel{
Type: tunneltest.TypeTCP,
ClientIdent: "http",
LocalAddr: "127.0.0.1:0",
RemoteAddrIdent: "tcp_all",
IP: addr.IP,
Handler: handlerEchoTCP,
}
clients = append(clients, client)
}
tt, err := tunneltest.Serve(tunnels)
if err != nil {
t.Fatal(err)
}
defer tt.Close()
var wg sync.WaitGroup
for i := 0; i < 100/len(clients); i++ {
wg.Add(len(clients))
for j, ident := range clients {
go func(ident string, i, j int) {
defer wg.Done()
msg := fmt.Sprintf("hello_%d_client_%d", j, i)
res, err := echoTCPIdent(tt, msg, ident)
if err != nil {
t.Errorf("echoTCP: %s", err)
}
if res != msg {
t.Errorf("got %q, want %q", res, msg)
}
}(ident, i, j)
}
}
wg.Wait()
}
