@marcel91200 / caddy Mirror · read-only
Fork 0

Fast and extensible multi-platform HTTP/1-2-3 web server with automatic HTTPS

Mirrored from https://github.com/Slazee/caddy.git

Synced Nov 11, 01:00 UTC

Code Commits Issues Pulls Cloud Agent CICD
master
master
go 175 lines 3.79 KB
Raw
1 package integration
2
3 import (
4 "bufio"
5 "fmt"
6 "io"
7 "net"
8 "net/textproto"
9 "strings"
10 "testing"
11 "time"
12
13 "github.com/caddyserver/caddy/v2/caddytest"
14 )
15
16 func TestReverseProxyUpgradeWithEncode(t *testing.T) {
17 tester := caddytest.NewTester(t)
18 backend := newUpgradeEchoBackend(t)
19 defer backend.Close()
20
21 tester.InitServer(fmt.Sprintf(`
22 {
23 admin localhost:2999
24 http_port 9080
25 https_port 9443
26 grace_period 1ns
27 skip_install_trust
28 }
29
30 localhost:9080 {
31 route {
32 encode gzip
33 reverse_proxy %s
34 }
35 }
36 `, backend.addr), "caddyfile")
37
38 client := newUpgradedStreamClientWithHeaders(t, map[string]string{
39 "Accept-Encoding": "gzip",
40 })
41 defer client.Close()
42
43 if err := client.echo("encode-upgrade\n"); err != nil {
44 t.Fatalf("upgraded stream echo through encode failed: %v", err)
45 }
46 }
47
48 func TestReverseProxyUpgradeWithInterceptHandleResponse(t *testing.T) {
49 tester := caddytest.NewTester(t)
50 backend := newUpgradeEchoBackend(t)
51 defer backend.Close()
52
53 tester.InitServer(fmt.Sprintf(`
54 {
55 admin localhost:2999
56 http_port 9080
57 https_port 9443
58 grace_period 1ns
59 skip_install_trust
60 }
61
62 localhost:9080 {
63 route {
64 intercept {
65 @upgrade status 101
66 handle_response @upgrade {
67 respond "should-not-run"
68 }
69 }
70 reverse_proxy %s
71 }
72 }
73 `, backend.addr), "caddyfile")
74
75 client := newUpgradedStreamClientWithHeaders(t, nil)
76 defer client.Close()
77
78 if err := client.echo("intercept-upgrade\n"); err != nil {
79 t.Fatalf("upgraded stream echo through intercept failed: %v", err)
80 }
81 }
82
83 func TestReverseProxyDetachedUpgradeWithAccessLogAndIntercept(t *testing.T) {
84 tester := caddytest.NewTester(t)
85 backend := newUpgradeEchoBackend(t)
86 defer backend.Close()
87 config := func(marker string) string {
88 return fmt.Sprintf(`
89 {
90 admin localhost:2999
91 http_port 9080
92 https_port 9443
93 grace_period 1ns
94 skip_install_trust
95 }
96 localhost:9080 {
97 log {
98 output discard
99 }
100 route {
101 header X-Reload %s
102 encode gzip
103 intercept {
104 @upgrade status 101
105 handle_response @upgrade {
106 respond "should-not-run"
107 }
108 }
109 reverse_proxy %s {
110 stream_detached
111 }
112 }
113 }
114 `, marker, backend.addr)
115 }
116 tester.InitServer(config("before"), "caddyfile")
117 client := newUpgradedStreamClientWithHeaders(t, map[string]string{"Accept-Encoding": "gzip"})
118 defer client.Close()
119 if err := client.echo("before-reload\n"); err != nil {
120 t.Fatalf("detached stream echo before reload failed: %v", err)
121 }
122 tester.InitServer(config("after"), "caddyfile")
123 if err := client.echo("after-reload\n"); err != nil {
124 t.Fatalf("detached stream echo after reload failed: %v", err)
125 }
126 }
127
128 func newUpgradedStreamClientWithHeaders(t *testing.T, extraHeaders map[string]string) *upgradedStreamClient {
129 t.Helper()
130
131 conn, err := net.DialTimeout("tcp", "127.0.0.1:9080", 5*time.Second)
132 if err != nil {
133 t.Fatalf("dialing caddy: %v", err)
134 }
135
136 requestLines := []string{
137 "GET /upgrade HTTP/1.1",
138 "Host: localhost:9080",
139 "Connection: Upgrade",
140 "Upgrade: stress-stream",
141 }
142 for k, v := range extraHeaders {
143 requestLines = append(requestLines, k+": "+v)
144 }
145 requestLines = append(requestLines, "", "")
146
147 if _, err := io.WriteString(conn, strings.Join(requestLines, "\r\n")); err != nil {
148 _ = conn.Close()
149 t.Fatalf("writing upgrade request: %v", err)
150 }
151
152 reader := bufio.NewReader(conn)
153 tproto := textproto.NewReader(reader)
154 statusLine, err := tproto.ReadLine()
155 if err != nil {
156 _ = conn.Close()
157 t.Fatalf("reading upgrade status line: %v", err)
158 }
159 if !strings.Contains(statusLine, "101") {
160 _ = conn.Close()
161 t.Fatalf("unexpected upgrade status: %s", statusLine)
162 }
163
164 headers, err := tproto.ReadMIMEHeader()
165 if err != nil {
166 _ = conn.Close()
167 t.Fatalf("reading upgrade headers: %v", err)
168 }
169 if !strings.EqualFold(headers.Get("Connection"), "Upgrade") {
170 _ = conn.Close()
171 t.Fatalf("unexpected upgrade response headers: %v", headers)
172 }
173
174 return &upgradedStreamClient{conn: conn, reader: reader}
175 }