Mercurial > hg > nginx-tests
annotate h2.t @ 1648:48d8c16d48ea
Tests: HTTP/2 connection timeout tests removed.
Both http2_recv_timeout and http2_idle_timeout are scheduled for removal.
| author | Sergey Kandaurov <pluknet@nginx.com> |
|---|---|
| date | Tue, 09 Feb 2021 10:51:56 +0300 |
| parents | 35beaf85de72 |
| children | 20e0ec3b4dec |
| rev | line source |
|---|---|
| 646 | 1 #!/usr/bin/perl |
| 2 | |
| 3 # (C) Sergey Kandaurov | |
| 4 # (C) Nginx, Inc. | |
| 5 | |
| 6 # Tests for HTTP/2 protocol [RFC7540]. | |
| 7 | |
| 8 ############################################################################### | |
| 9 | |
| 10 use warnings; | |
| 11 use strict; | |
| 12 | |
| 13 use Test::More; | |
| 14 | |
| 15 use Socket qw/ CRLF /; | |
| 16 | |
| 17 BEGIN { use FindBin; chdir($FindBin::Bin); } | |
| 18 | |
| 19 use lib 'lib'; | |
| 20 use Test::Nginx; | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
21 use Test::Nginx::HTTP2; |
| 646 | 22 |
| 23 ############################################################################### | |
| 24 | |
| 25 select STDERR; $| = 1; | |
| 26 select STDOUT; $| = 1; | |
| 27 | |
|
1002
3b1ee8acc4db
Tests: added charset and gzip prerequisites in h2.t.
Sergey Kandaurov <pluknet@nginx.com>
parents:
997
diff
changeset
|
28 my $t = Test::Nginx->new()->has(qw/http http_v2 proxy rewrite charset gzip/) |
|
1648
48d8c16d48ea
Tests: HTTP/2 connection timeout tests removed.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1647
diff
changeset
|
29 ->plan(144); |
|
704
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
30 |
| 646 | 31 $t->write_file_expand('nginx.conf', <<'EOF'); |
| 32 | |
| 33 %%TEST_GLOBALS%% | |
| 34 | |
| 35 daemon off; | |
| 36 | |
| 37 events { | |
| 38 } | |
| 39 | |
| 40 http { | |
| 41 %%TEST_GLOBALS_HTTP%% | |
| 42 | |
| 43 server { | |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
44 listen 127.0.0.1:8080 http2; |
|
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
45 listen 127.0.0.1:8081; |
| 646 | 46 server_name localhost; |
| 47 | |
| 48 location / { | |
| 49 add_header X-Header X-Foo; | |
| 50 add_header X-Sent-Foo $http_x_foo; | |
| 51 add_header X-Referer $http_referer; | |
| 52 return 200 'body'; | |
| 53 } | |
| 54 location /t { | |
| 55 } | |
| 56 location /gzip.html { | |
| 57 gzip on; | |
| 58 gzip_min_length 0; | |
|
847
7de036e89770
Tests: added HTTP/2 test with gzip vary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
846
diff
changeset
|
59 gzip_vary on; |
| 646 | 60 alias %%TESTDIR%%/t2.html; |
| 61 } | |
|
680
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
62 location /frame_size { |
|
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
63 http2_chunk_size 64k; |
|
1184
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
64 alias %%TESTDIR%%; |
|
680
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
65 output_buffers 2 1m; |
|
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
66 } |
|
651
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
67 location /chunk_size { |
|
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
68 http2_chunk_size 1; |
|
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
69 return 200 'body'; |
|
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
70 } |
| 646 | 71 location /redirect { |
| 72 error_page 405 /; | |
| 73 return 405; | |
| 74 } | |
| 75 location /return301 { | |
| 76 return 301; | |
| 77 } | |
| 78 location /return301_absolute { | |
| 79 return 301 text; | |
| 80 } | |
| 81 location /return301_relative { | |
| 82 return 301 /; | |
| 83 } | |
|
846
9b5e1c5f0240
Tests: added HTTP/2 test with charset.
Sergey Kandaurov <pluknet@nginx.com>
parents:
845
diff
changeset
|
84 location /charset { |
|
9b5e1c5f0240
Tests: added HTTP/2 test with charset.
Sergey Kandaurov <pluknet@nginx.com>
parents:
845
diff
changeset
|
85 charset utf-8; |
|
9b5e1c5f0240
Tests: added HTTP/2 test with charset.
Sergey Kandaurov <pluknet@nginx.com>
parents:
845
diff
changeset
|
86 return 200; |
|
9b5e1c5f0240
Tests: added HTTP/2 test with charset.
Sergey Kandaurov <pluknet@nginx.com>
parents:
845
diff
changeset
|
87 } |
| 646 | 88 } |
| 89 | |
| 90 server { | |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
91 listen 127.0.0.1:8082 http2; |
| 646 | 92 server_name localhost; |
| 93 return 200 first; | |
| 94 } | |
| 95 | |
| 96 server { | |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
97 listen 127.0.0.1:8082 http2; |
| 646 | 98 server_name localhost2; |
| 99 return 200 second; | |
| 100 } | |
|
654
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
101 |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
102 server { |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
103 listen 127.0.0.1:8083 http2; |
|
654
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
104 server_name localhost; |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
105 |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
106 http2_max_concurrent_streams 1; |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
107 } |
|
684
96666f621dbc
Tests: added http2_max_field_size and http2_max_header_size tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
680
diff
changeset
|
108 |
|
96666f621dbc
Tests: added http2_max_field_size and http2_max_header_size tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
680
diff
changeset
|
109 server { |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
110 listen 127.0.0.1:8084 http2; |
|
714
ccc9f389e1f8
Tests: HTTP/2 connection timeout tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
712
diff
changeset
|
111 server_name localhost; |
|
ccc9f389e1f8
Tests: HTTP/2 connection timeout tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
712
diff
changeset
|
112 |
|
842
60b3e0cfba77
Tests: adjusted h2.t configuration for per-request timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
841
diff
changeset
|
113 client_header_timeout 1s; |
|
60b3e0cfba77
Tests: adjusted h2.t configuration for per-request timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
841
diff
changeset
|
114 send_timeout 1s; |
|
714
ccc9f389e1f8
Tests: HTTP/2 connection timeout tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
712
diff
changeset
|
115 } |
|
ccc9f389e1f8
Tests: HTTP/2 connection timeout tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
712
diff
changeset
|
116 |
|
ccc9f389e1f8
Tests: HTTP/2 connection timeout tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
712
diff
changeset
|
117 server { |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
118 listen 127.0.0.1:8085 http2; |
|
714
ccc9f389e1f8
Tests: HTTP/2 connection timeout tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
712
diff
changeset
|
119 server_name localhost; |
|
ccc9f389e1f8
Tests: HTTP/2 connection timeout tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
712
diff
changeset
|
120 |
|
842
60b3e0cfba77
Tests: adjusted h2.t configuration for per-request timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
841
diff
changeset
|
121 client_body_timeout 1s; |
|
755
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
122 |
|
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
123 location /proxy2/ { |
|
876
a6abbfed42c0
Tests: split HTTP/2 tests, HTTP2 package introduced.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
871
diff
changeset
|
124 add_header X-Body $request_body; |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
125 proxy_pass http://127.0.0.1:8081/; |
|
755
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
126 } |
|
714
ccc9f389e1f8
Tests: HTTP/2 connection timeout tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
712
diff
changeset
|
127 } |
|
763
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
128 |
|
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
129 server { |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
130 listen 127.0.0.1:8086 http2; |
|
763
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
131 server_name localhost; |
|
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
132 |
|
990
eb49d29d5447
Tests: redo 892737e9fd31 without flaky send_timeout adjustments.
Sergey Kandaurov <pluknet@nginx.com>
parents:
984
diff
changeset
|
133 send_timeout 1s; |
|
763
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
134 } |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
135 |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
136 server { |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
137 listen 127.0.0.1:8087 http2; |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
138 server_name localhost; |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
139 |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
140 client_header_timeout 1s; |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
141 client_body_timeout 1s; |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
142 |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
143 location /proxy/ { |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
144 proxy_pass http://127.0.0.1:8081/; |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
145 } |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
146 } |
| 646 | 147 } |
| 148 | |
| 149 EOF | |
| 150 | |
|
741
a2e7f5ff3aa8
Tests: hid unwanted output with old OpenSSL.
Sergey Kandaurov <pluknet@nginx.com>
parents:
740
diff
changeset
|
151 $t->run(); |
| 646 | 152 |
| 153 # file size is slightly beyond initial window size: 2**16 + 80 bytes | |
| 154 | |
| 155 $t->write_file('t1.html', | |
| 156 join('', map { sprintf "X%04dXXX", $_ } (1 .. 8202))); | |
| 157 $t->write_file('tbig.html', | |
|
723
bc4d6e2bd031
Tests: adjusted HTTP/2 test to trigger write handler in v2 module.
Sergey Kandaurov <pluknet@nginx.com>
parents:
722
diff
changeset
|
158 join('', map { sprintf "XX%06dXX", $_ } (1 .. 500000))); |
| 646 | 159 |
| 160 $t->write_file('t2.html', 'SEE-THIS'); | |
| 161 | |
| 162 ############################################################################### | |
| 163 | |
|
738
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
164 # Upgrade mechanism |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
165 |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
166 my $r = http(<<EOF); |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
167 GET / HTTP/1.1 |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
168 Host: localhost |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
169 Connection: Upgrade, HTTP2-Settings |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
170 Upgrade: h2c |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
171 HTTP2-Settings: AAMAAABkAAQAAP__ |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
172 |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
173 EOF |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
174 |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
175 SKIP: { |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
176 skip 'no Upgrade-based negotiation', 2 if $r !~ m!HTTP/1.1 101!; |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
177 |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
178 like($r, qr!Connection: Upgrade!, 'upgrade - connection'); |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
179 like($r, qr!Upgrade: h2c!, 'upgrade - token'); |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
180 |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
181 } |
|
0881219c0699
Tests: HTTP/2 tests for Upgrade-based negotiation.
Sergey Kandaurov <pluknet@nginx.com>
parents:
737
diff
changeset
|
182 |
| 646 | 183 # SETTINGS |
| 184 | |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
185 my $s = Test::Nginx::HTTP2->new(port(8080), pure => 1); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
186 my $frames = $s->read(all => [ |
| 646 | 187 { type => 'WINDOW_UPDATE' }, |
| 188 { type => 'SETTINGS'} | |
| 189 ]); | |
| 190 | |
| 191 my ($frame) = grep { $_->{type} eq 'WINDOW_UPDATE' } @$frames; | |
| 192 ok($frame, 'WINDOW_UPDATE frame'); | |
| 193 is($frame->{flags}, 0, 'WINDOW_UPDATE zero flags'); | |
| 194 is($frame->{sid}, 0, 'WINDOW_UPDATE zero sid'); | |
| 195 is($frame->{length}, 4, 'WINDOW_UPDATE fixed length'); | |
| 196 | |
| 197 ($frame) = grep { $_->{type} eq 'SETTINGS' } @$frames; | |
| 198 ok($frame, 'SETTINGS frame'); | |
| 199 is($frame->{flags}, 0, 'SETTINGS flags'); | |
|
655
75ecd26b8831
Tests: HTTP/2 tests cleanup.
Sergey Kandaurov <pluknet@nginx.com>
parents:
654
diff
changeset
|
200 is($frame->{sid}, 0, 'SETTINGS stream'); |
| 646 | 201 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
202 $s->h2_settings(1); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
203 $s->h2_settings(0); |
| 646 | 204 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
205 $frames = $s->read(all => [{ type => 'SETTINGS' }]); |
| 646 | 206 |
| 207 ($frame) = grep { $_->{type} eq 'SETTINGS' } @$frames; | |
| 208 ok($frame, 'SETTINGS frame ack'); | |
| 209 is($frame->{flags}, 1, 'SETTINGS flags ack'); | |
| 210 | |
|
1183
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
211 # SETTINGS - no ack on PROTOCOL_ERROR |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
212 |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
213 $s = Test::Nginx::HTTP2->new(port(8080), pure => 1); |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
214 $frames = $s->read(all => [ |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
215 { type => 'WINDOW_UPDATE' }, |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
216 { type => 'SETTINGS'} |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
217 ]); |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
218 |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
219 $s->h2_settings(1); |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
220 $s->h2_settings(0, 0x5 => 42); |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
221 |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
222 $frames = $s->read(all => [ |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
223 { type => 'SETTINGS'}, |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
224 { type => 'GOAWAY' } |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
225 ]); |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
226 |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
227 ($frame) = grep { $_->{type} eq 'SETTINGS' } @$frames; |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
228 is($frame, undef, 'SETTINGS PROTOCOL_ERROR - no ack'); |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
229 |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
230 ($frame) = grep { $_->{type} eq 'GOAWAY' } @$frames; |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
231 ok($frame, 'SETTINGS PROTOCOL_ERROR - GOAWAY'); |
|
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
232 |
| 646 | 233 # PING |
| 234 | |
|
1183
878696cb8510
Tests: added HTTP/2 SETTINGS test for no ack on PROTOCOL_ERROR.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1182
diff
changeset
|
235 $s = Test::Nginx::HTTP2->new(); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
236 $s->h2_ping('SEE-THIS'); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
237 $frames = $s->read(all => [{ type => 'PING' }]); |
| 646 | 238 |
| 239 ($frame) = grep { $_->{type} eq "PING" } @$frames; | |
| 240 ok($frame, 'PING frame'); | |
| 241 is($frame->{value}, 'SEE-THIS', 'PING payload'); | |
| 242 is($frame->{flags}, 1, 'PING flags ack'); | |
|
655
75ecd26b8831
Tests: HTTP/2 tests cleanup.
Sergey Kandaurov <pluknet@nginx.com>
parents:
654
diff
changeset
|
243 is($frame->{sid}, 0, 'PING stream'); |
| 646 | 244 |
|
759
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
245 # GOAWAY |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
246 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
247 Test::Nginx::HTTP2->new()->h2_goaway(0, 0, 5); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
248 Test::Nginx::HTTP2->new()->h2_goaway(0, 0, 5, 'foobar'); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
249 Test::Nginx::HTTP2->new()->h2_goaway(0, 0, 5, 'foobar', split => [ 8, 8, 4 ]); |
|
759
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
250 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
251 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
252 $s->h2_goaway(0, 0, 5); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
253 $s->h2_goaway(0, 0, 5); |
|
759
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
254 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
255 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
256 $s->h2_goaway(0, 0, 5, 'foobar', len => 0); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
257 $frames = $s->read(all => [{ type => "GOAWAY" }]); |
|
759
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
258 |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
259 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
260 ok($frame, 'GOAWAY invalid length - GOAWAY frame'); |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
261 is($frame->{code}, 6, 'GOAWAY invalid length - GOAWAY FRAME_SIZE_ERROR'); |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
262 |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
263 # 6.8. GOAWAY |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
264 # An endpoint MUST treat a GOAWAY frame with a stream identifier other |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
265 # than 0x0 as a connection error (Section 5.4.1) of type PROTOCOL_ERROR. |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
266 |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
267 TODO: { |
|
1589
f145dce55f32
Tests: h2.t TODO adjusted, GOAWAY fix committed.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1548
diff
changeset
|
268 local $TODO = 'not yet' unless $t->has_version('1.19.3'); |
|
759
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
269 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
270 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
271 $s->h2_goaway(1, 0, 5, 'foobar'); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
272 $frames = $s->read(all => [{ type => "GOAWAY" }], wait => 0.5); |
|
759
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
273 |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
274 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
275 ok($frame, 'GOAWAY invalid stream - GOAWAY frame'); |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
276 is($frame->{code}, 1, 'GOAWAY invalid stream - GOAWAY PROTOCOL_ERROR'); |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
277 |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
278 } |
|
6406eee6366c
Tests: added simple HTTP/2 tests for client GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
758
diff
changeset
|
279 |
|
760
4db976a91540
Tests: HTTP/2 tests for client-initiated PUSH_PROMISE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
759
diff
changeset
|
280 # client-initiated PUSH_PROMISE, just to ensure nothing went wrong |
|
4db976a91540
Tests: HTTP/2 tests for client-initiated PUSH_PROMISE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
759
diff
changeset
|
281 # N.B. other implementation returns zero code, which is not anyhow regulated |
|
4db976a91540
Tests: HTTP/2 tests for client-initiated PUSH_PROMISE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
759
diff
changeset
|
282 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
283 $s = Test::Nginx::HTTP2->new(); |
|
1174
ec9ddfed9b63
Tests: handled SIGPIPE in h2.t.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1108
diff
changeset
|
284 { |
|
ec9ddfed9b63
Tests: handled SIGPIPE in h2.t.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1108
diff
changeset
|
285 local $SIG{PIPE} = 'IGNORE'; |
|
ec9ddfed9b63
Tests: handled SIGPIPE in h2.t.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1108
diff
changeset
|
286 syswrite($s->{socket}, pack("x2C2xN", 4, 0x5, 1)); |
|
ec9ddfed9b63
Tests: handled SIGPIPE in h2.t.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1108
diff
changeset
|
287 } |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
288 $frames = $s->read(all => [{ type => "GOAWAY" }]); |
|
760
4db976a91540
Tests: HTTP/2 tests for client-initiated PUSH_PROMISE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
759
diff
changeset
|
289 |
|
4db976a91540
Tests: HTTP/2 tests for client-initiated PUSH_PROMISE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
759
diff
changeset
|
290 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; |
|
4db976a91540
Tests: HTTP/2 tests for client-initiated PUSH_PROMISE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
759
diff
changeset
|
291 ok($frame, 'client-initiated PUSH_PROMISE - GOAWAY frame'); |
|
4db976a91540
Tests: HTTP/2 tests for client-initiated PUSH_PROMISE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
759
diff
changeset
|
292 is($frame->{code}, 1, 'client-initiated PUSH_PROMISE - GOAWAY PROTOCOL_ERROR'); |
|
4db976a91540
Tests: HTTP/2 tests for client-initiated PUSH_PROMISE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
759
diff
changeset
|
293 |
| 646 | 294 # GET |
| 295 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
296 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
297 my $sid = $s->new_stream(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
298 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 299 |
| 300 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 301 ok($frame, 'HEADERS frame'); | |
| 302 is($frame->{sid}, $sid, 'HEADERS stream'); | |
| 303 is($frame->{headers}->{':status'}, 200, 'HEADERS status'); | |
| 304 is($frame->{headers}->{'x-header'}, 'X-Foo', 'HEADERS header'); | |
| 305 | |
| 306 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
| 307 ok($frame, 'DATA frame'); | |
| 308 is($frame->{length}, length 'body', 'DATA length'); | |
| 309 is($frame->{data}, 'body', 'DATA payload'); | |
| 310 | |
| 311 # GET in the new stream on same connection | |
| 312 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
313 $sid = $s->new_stream(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
314 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 315 |
| 316 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 317 is($frame->{sid}, $sid, 'HEADERS stream 2'); | |
| 318 is($frame->{headers}->{':status'}, 200, 'HEADERS status 2'); | |
| 319 is($frame->{headers}->{'x-header'}, 'X-Foo', 'HEADERS header 2'); | |
| 320 | |
| 321 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
| 322 ok($frame, 'DATA frame 2'); | |
| 323 is($frame->{sid}, $sid, 'HEADERS stream 2'); | |
| 324 is($frame->{length}, length 'body', 'DATA length 2'); | |
| 325 is($frame->{data}, 'body', 'DATA payload 2'); | |
| 326 | |
| 327 # HEAD | |
| 328 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
329 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
330 $sid = $s->new_stream({ method => 'HEAD' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
331 $frames = $s->read(all => [{ sid => $sid, fin => 0x4 }]); |
| 646 | 332 |
| 333 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 334 is($frame->{sid}, $sid, 'HEAD - HEADERS'); | |
| 335 is($frame->{headers}->{':status'}, 200, 'HEAD - HEADERS status'); | |
| 336 is($frame->{headers}->{'x-header'}, 'X-Foo', 'HEAD - HEADERS header'); | |
| 337 | |
| 338 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
| 339 is($frame, undef, 'HEAD - no body'); | |
| 340 | |
| 341 # range filter | |
| 342 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
343 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
344 $sid = $s->new_stream({ headers => [ |
| 646 | 345 { name => ':method', value => 'GET', mode => 0 }, |
| 346 { name => ':scheme', value => 'http', mode => 0 }, | |
| 347 { name => ':path', value => '/t1.html', mode => 1 }, | |
|
653
5ad620022234
Tests: HTTP/2 tests adapted to send ':authority' where needed.
Sergey Kandaurov <pluknet@nginx.com>
parents:
652
diff
changeset
|
348 { name => ':authority', value => 'localhost', mode => 1 }, |
| 646 | 349 { name => 'range', value => 'bytes=10-19', mode => 1 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
350 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 351 |
| 352 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 353 is($frame->{headers}->{':status'}, 206, 'range - HEADERS status'); | |
| 354 | |
| 355 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
| 356 is($frame->{length}, 10, 'range - DATA length'); | |
| 357 is($frame->{data}, '002XXXX000', 'range - DATA payload'); | |
| 358 | |
|
651
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
359 # http2_chunk_size=1 |
|
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
360 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
361 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
362 $sid = $s->new_stream({ path => '/chunk_size' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
363 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
651
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
364 |
|
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
365 my @data = grep { $_->{type} eq "DATA" } @$frames; |
|
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
366 is(@data, 4, 'chunk_size frames'); |
|
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
367 is(join(' ', map { $_->{data} } @data), 'b o d y', 'chunk_size data'); |
|
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
368 is(join(' ', map { $_->{flags} } @data), '0 0 0 1', 'chunk_size flags'); |
|
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
369 |
| 646 | 370 # CONTINUATION |
| 371 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
372 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
373 $sid = $s->new_stream({ continuation => 1, headers => [ |
| 646 | 374 { name => ':method', value => 'HEAD', mode => 1 }, |
| 375 { name => ':scheme', value => 'http', mode => 0 }, | |
|
653
5ad620022234
Tests: HTTP/2 tests adapted to send ':authority' where needed.
Sergey Kandaurov <pluknet@nginx.com>
parents:
652
diff
changeset
|
376 { name => ':path', value => '/', mode => 0 }, |
|
5ad620022234
Tests: HTTP/2 tests adapted to send ':authority' where needed.
Sergey Kandaurov <pluknet@nginx.com>
parents:
652
diff
changeset
|
377 { name => ':authority', value => 'localhost', mode => 1 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
378 $s->h2_continue($sid, { continuation => 1, headers => [ |
| 646 | 379 { name => 'x-foo', value => 'X-Bar', mode => 2 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
380 $s->h2_continue($sid, { headers => [ |
| 646 | 381 { name => 'referer', value => 'foo', mode => 2 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
382 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 383 |
| 384 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
| 385 is($frame, undef, 'CONTINUATION - fragment 1'); | |
| 386 | |
| 387 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 388 is($frame->{headers}->{'x-sent-foo'}, 'X-Bar', 'CONTINUATION - fragment 2'); | |
| 389 is($frame->{headers}->{'x-referer'}, 'foo', 'CONTINUATION - fragment 3'); | |
| 390 | |
|
699
5768830f01c4
Tests: HTTP/2 test for CONTINUATION in the middle of header field.
Sergey Kandaurov <pluknet@nginx.com>
parents:
698
diff
changeset
|
391 # CONTINUATION - in the middle of request header field |
|
5768830f01c4
Tests: HTTP/2 test for CONTINUATION in the middle of header field.
Sergey Kandaurov <pluknet@nginx.com>
parents:
698
diff
changeset
|
392 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
393 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
394 $sid = $s->new_stream({ continuation => [ 2, 4, 1, 5 ], headers => [ |
|
699
5768830f01c4
Tests: HTTP/2 test for CONTINUATION in the middle of header field.
Sergey Kandaurov <pluknet@nginx.com>
parents:
698
diff
changeset
|
395 { name => ':method', value => 'HEAD', mode => 1 }, |
|
5768830f01c4
Tests: HTTP/2 test for CONTINUATION in the middle of header field.
Sergey Kandaurov <pluknet@nginx.com>
parents:
698
diff
changeset
|
396 { name => ':scheme', value => 'http', mode => 0 }, |
|
5768830f01c4
Tests: HTTP/2 test for CONTINUATION in the middle of header field.
Sergey Kandaurov <pluknet@nginx.com>
parents:
698
diff
changeset
|
397 { name => ':path', value => '/', mode => 0 }, |
|
5768830f01c4
Tests: HTTP/2 test for CONTINUATION in the middle of header field.
Sergey Kandaurov <pluknet@nginx.com>
parents:
698
diff
changeset
|
398 { name => ':authority', value => 'localhost', mode => 1 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
399 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
699
5768830f01c4
Tests: HTTP/2 test for CONTINUATION in the middle of header field.
Sergey Kandaurov <pluknet@nginx.com>
parents:
698
diff
changeset
|
400 |
|
5768830f01c4
Tests: HTTP/2 test for CONTINUATION in the middle of header field.
Sergey Kandaurov <pluknet@nginx.com>
parents:
698
diff
changeset
|
401 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; |
|
5768830f01c4
Tests: HTTP/2 test for CONTINUATION in the middle of header field.
Sergey Kandaurov <pluknet@nginx.com>
parents:
698
diff
changeset
|
402 is($frame->{headers}->{':status'}, 200, 'CONTINUATION - in header field'); |
|
5768830f01c4
Tests: HTTP/2 test for CONTINUATION in the middle of header field.
Sergey Kandaurov <pluknet@nginx.com>
parents:
698
diff
changeset
|
403 |
|
761
01feb5d4d7a4
Tests: HTTP/2 test for CONTINUATION on a closed stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
760
diff
changeset
|
404 # CONTINUATION on a closed stream |
|
01feb5d4d7a4
Tests: HTTP/2 test for CONTINUATION on a closed stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
760
diff
changeset
|
405 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
406 $s->h2_continue(1, { headers => [ |
|
761
01feb5d4d7a4
Tests: HTTP/2 test for CONTINUATION on a closed stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
760
diff
changeset
|
407 { name => 'x-foo', value => 'X-Bar', mode => 2 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
408 $frames = $s->read(all => [{ sid => 1, fin => 1 }]); |
|
761
01feb5d4d7a4
Tests: HTTP/2 test for CONTINUATION on a closed stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
760
diff
changeset
|
409 |
|
01feb5d4d7a4
Tests: HTTP/2 test for CONTINUATION on a closed stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
760
diff
changeset
|
410 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; |
|
01feb5d4d7a4
Tests: HTTP/2 test for CONTINUATION on a closed stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
760
diff
changeset
|
411 is($frame->{type}, 'GOAWAY', 'GOAWAY - CONTINUATION closed stream'); |
|
01feb5d4d7a4
Tests: HTTP/2 test for CONTINUATION on a closed stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
760
diff
changeset
|
412 is($frame->{code}, 1, 'GOAWAY - CONTINUATION closed stream - PROTOCOL_ERROR'); |
|
01feb5d4d7a4
Tests: HTTP/2 test for CONTINUATION on a closed stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
760
diff
changeset
|
413 |
| 646 | 414 # frame padding |
| 415 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
416 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
417 $sid = $s->new_stream({ padding => 42, headers => [ |
| 646 | 418 { name => ':method', value => 'GET', mode => 0 }, |
| 419 { name => ':scheme', value => 'http', mode => 0 }, | |
|
653
5ad620022234
Tests: HTTP/2 tests adapted to send ':authority' where needed.
Sergey Kandaurov <pluknet@nginx.com>
parents:
652
diff
changeset
|
420 { name => ':path', value => '/', mode => 0 }, |
|
5ad620022234
Tests: HTTP/2 tests adapted to send ':authority' where needed.
Sergey Kandaurov <pluknet@nginx.com>
parents:
652
diff
changeset
|
421 { name => ':authority', value => 'localhost', mode => 1 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
422 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 423 |
| 424 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 425 is($frame->{headers}->{':status'}, 200, 'padding - HEADERS status'); | |
| 426 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
427 $sid = $s->new_stream({ headers => [ |
| 646 | 428 { name => ':method', value => 'GET', mode => 0 }, |
| 429 { name => ':scheme', value => 'http', mode => 0 }, | |
|
653
5ad620022234
Tests: HTTP/2 tests adapted to send ':authority' where needed.
Sergey Kandaurov <pluknet@nginx.com>
parents:
652
diff
changeset
|
430 { name => ':path', value => '/', mode => 0 }, |
|
5ad620022234
Tests: HTTP/2 tests adapted to send ':authority' where needed.
Sergey Kandaurov <pluknet@nginx.com>
parents:
652
diff
changeset
|
431 { name => ':authority', value => 'localhost', mode => 1 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
432 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 433 |
| 434 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 435 is($frame->{headers}->{':status'}, 200, 'padding - next stream'); | |
| 436 | |
|
821
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
437 # padding followed by CONTINUATION |
|
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
438 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
439 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
440 $sid = $s->new_stream({ padding => 42, continuation => [ 2, 4, 1, 5 ], |
|
821
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
441 headers => [ |
|
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
442 { name => ':method', value => 'GET', mode => 1 }, |
|
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
443 { name => ':scheme', value => 'http', mode => 0 }, |
|
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
444 { name => ':path', value => '/', mode => 0 }, |
|
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
445 { name => ':authority', value => 'localhost', mode => 1 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
446 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
821
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
447 |
|
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
448 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; |
|
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
449 is($frame->{headers}->{':status'}, 200, 'padding - CONTINUATION'); |
|
d75000247e1f
Tests: added HTTP/2 test for padded HEADERS with CONTINUATION.
Sergey Kandaurov <pluknet@nginx.com>
parents:
818
diff
changeset
|
450 |
| 646 | 451 # internal redirect |
| 452 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
453 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
454 $sid = $s->new_stream({ path => '/redirect' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
455 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 456 |
| 457 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 458 is($frame->{headers}->{':status'}, 405, 'redirect - HEADERS'); | |
| 459 | |
| 460 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
| 461 ok($frame, 'redirect - DATA'); | |
| 462 is($frame->{data}, 'body', 'redirect - DATA payload'); | |
| 463 | |
| 464 # return 301 with absolute URI | |
| 465 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
466 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
467 $sid = $s->new_stream({ path => '/return301_absolute' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
468 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 469 |
| 470 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 471 is($frame->{headers}->{':status'}, 301, 'return 301 absolute - status'); | |
| 472 is($frame->{headers}->{'location'}, 'text', 'return 301 absolute - location'); | |
| 473 | |
| 474 # return 301 with relative URI | |
| 475 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
476 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
477 $sid = $s->new_stream({ path => '/return301_relative' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
478 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 479 |
| 480 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 481 is($frame->{headers}->{':status'}, 301, 'return 301 relative - status'); | |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
482 is($frame->{headers}->{'location'}, 'http://localhost:' . port(8080) . '/', |
| 646 | 483 'return 301 relative - location'); |
| 484 | |
| 485 # return 301 with relative URI and ':authority' request header field | |
| 486 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
487 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
488 $sid = $s->new_stream({ headers => [ |
| 646 | 489 { name => ':method', value => 'GET', mode => 0 }, |
| 490 { name => ':scheme', value => 'http', mode => 0 }, | |
| 491 { name => ':path', value => '/return301_relative', mode => 2 }, | |
| 492 { name => ':authority', value => 'localhost', mode => 2 }]}); | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
493 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 494 |
| 495 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 496 is($frame->{headers}->{':status'}, 301, | |
| 497 'return 301 relative - authority - status'); | |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
498 is($frame->{headers}->{'location'}, 'http://localhost:' . port(8080) . '/', |
| 646 | 499 'return 301 relative - authority - location'); |
| 500 | |
| 501 # return 301 with relative URI and 'host' request header field | |
| 502 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
503 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
504 $sid = $s->new_stream({ headers => [ |
| 646 | 505 { name => ':method', value => 'GET', mode => 0 }, |
| 506 { name => ':scheme', value => 'http', mode => 0 }, | |
| 507 { name => ':path', value => '/return301_relative', mode => 2 }, | |
| 508 { name => 'host', value => 'localhost', mode => 2 }]}); | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
509 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 510 |
| 511 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 512 is($frame->{headers}->{':status'}, 301, | |
| 513 'return 301 relative - host - status'); | |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
514 is($frame->{headers}->{'location'}, 'http://localhost:' . port(8080) . '/', |
| 646 | 515 'return 301 relative - host - location'); |
| 516 | |
| 517 # virtual host | |
| 518 | |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
519 $s = Test::Nginx::HTTP2->new(port(8082)); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
520 $sid = $s->new_stream({ headers => [ |
| 646 | 521 { name => ':method', value => 'GET', mode => 0 }, |
| 522 { name => ':scheme', value => 'http', mode => 0 }, | |
| 523 { name => ':path', value => '/', mode => 0 }, | |
| 524 { name => 'host', value => 'localhost', mode => 2 }]}); | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
525 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 526 |
| 527 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 528 is($frame->{headers}->{':status'}, 200, | |
| 529 'virtual host - host - status'); | |
| 530 | |
| 531 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
| 532 is($frame->{data}, 'first', 'virtual host - host - DATA'); | |
| 533 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
534 $sid = $s->new_stream({ headers => [ |
| 646 | 535 { name => ':method', value => 'GET', mode => 0 }, |
| 536 { name => ':scheme', value => 'http', mode => 0 }, | |
| 537 { name => ':path', value => '/', mode => 0 }, | |
| 538 { name => ':authority', value => 'localhost', mode => 2 }]}); | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
539 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 540 |
| 541 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 542 is($frame->{headers}->{':status'}, 200, | |
| 543 'virtual host - authority - status'); | |
| 544 | |
| 545 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
| 546 is($frame->{data}, 'first', 'virtual host - authority - DATA'); | |
| 547 | |
| 548 # virtual host - second | |
| 549 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
550 $sid = $s->new_stream({ headers => [ |
| 646 | 551 { name => ':method', value => 'GET', mode => 0 }, |
| 552 { name => ':scheme', value => 'http', mode => 0 }, | |
| 553 { name => ':path', value => '/', mode => 0 }, | |
| 554 { name => 'host', value => 'localhost2', mode => 2 }]}); | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
555 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 556 |
| 557 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 558 is($frame->{headers}->{':status'}, 200, | |
| 559 'virtual host 2 - host - status'); | |
| 560 | |
| 561 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
| 562 is($frame->{data}, 'second', 'virtual host 2 - host - DATA'); | |
| 563 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
564 $sid = $s->new_stream({ headers => [ |
| 646 | 565 { name => ':method', value => 'GET', mode => 0 }, |
| 566 { name => ':scheme', value => 'http', mode => 0 }, | |
| 567 { name => ':path', value => '/', mode => 0 }, | |
| 568 { name => ':authority', value => 'localhost2', mode => 2 }]}); | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
569 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 570 |
| 571 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 572 is($frame->{headers}->{':status'}, 200, | |
| 573 'virtual host 2 - authority - status'); | |
| 574 | |
| 575 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
| 576 is($frame->{data}, 'second', 'virtual host 2 - authority - DATA'); | |
| 577 | |
| 578 # gzip tests for internal nginx version | |
| 579 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
580 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
581 $sid = $s->new_stream({ headers => [ |
| 646 | 582 { name => ':method', value => 'GET', mode => 0 }, |
| 583 { name => ':scheme', value => 'http', mode => 0 }, | |
| 584 { name => ':path', value => '/gzip.html' }, | |
|
653
5ad620022234
Tests: HTTP/2 tests adapted to send ':authority' where needed.
Sergey Kandaurov <pluknet@nginx.com>
parents:
652
diff
changeset
|
585 { name => ':authority', value => 'localhost', mode => 1 }, |
| 646 | 586 { name => 'accept-encoding', value => 'gzip' }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
587 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 588 |
| 589 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; | |
| 590 is($frame->{headers}->{'content-encoding'}, 'gzip', 'gzip - encoding'); | |
|
847
7de036e89770
Tests: added HTTP/2 test with gzip vary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
846
diff
changeset
|
591 is($frame->{headers}->{'vary'}, 'Accept-Encoding', 'gzip - vary'); |
| 646 | 592 |
| 593 ($frame) = grep { $_->{type} eq "DATA" } @$frames; | |
|
647
4e36550410b3
Tests: h2.t fixes for older perl versions, and gzip test.
Sergey Kandaurov <pluknet@nginx.com>
parents:
646
diff
changeset
|
594 gunzip_like($frame->{data}, qr/^SEE-THIS\Z/, 'gzip - DATA'); |
| 646 | 595 |
|
846
9b5e1c5f0240
Tests: added HTTP/2 test with charset.
Sergey Kandaurov <pluknet@nginx.com>
parents:
845
diff
changeset
|
596 # charset |
|
9b5e1c5f0240
Tests: added HTTP/2 test with charset.
Sergey Kandaurov <pluknet@nginx.com>
parents:
845
diff
changeset
|
597 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
598 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
599 $sid = $s->new_stream({ path => '/charset' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
600 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
846
9b5e1c5f0240
Tests: added HTTP/2 test with charset.
Sergey Kandaurov <pluknet@nginx.com>
parents:
845
diff
changeset
|
601 |
|
9b5e1c5f0240
Tests: added HTTP/2 test with charset.
Sergey Kandaurov <pluknet@nginx.com>
parents:
845
diff
changeset
|
602 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; |
|
9b5e1c5f0240
Tests: added HTTP/2 test with charset.
Sergey Kandaurov <pluknet@nginx.com>
parents:
845
diff
changeset
|
603 is($frame->{headers}->{'content-type'}, 'text/plain; charset=utf-8', 'charset'); |
|
9b5e1c5f0240
Tests: added HTTP/2 test with charset.
Sergey Kandaurov <pluknet@nginx.com>
parents:
845
diff
changeset
|
604 |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
605 # partial request header frame received (field split), |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
606 # the rest of frame is received after client header timeout |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
607 |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
608 $s = Test::Nginx::HTTP2->new(port(8087)); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
609 $sid = $s->new_stream({ path => '/t2.html', split => [35], |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
610 split_delay => 2.1 }); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
611 $frames = $s->read(all => [{ type => 'RST_STREAM' }]); |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
612 |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
613 ($frame) = grep { $_->{type} eq "RST_STREAM" } @$frames; |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
614 ok($frame, 'client header timeout'); |
|
841
6a401b5fa812
Tests: check timed out HTTP/2 streams for proper RST_STREAM code.
Sergey Kandaurov <pluknet@nginx.com>
parents:
840
diff
changeset
|
615 is($frame->{code}, 1, 'client header timeout - protocol error'); |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
616 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
617 $s->h2_ping('SEE-THIS'); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
618 $frames = $s->read(all => [{ type => 'PING' }]); |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
619 |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
620 ($frame) = grep { $_->{type} eq "PING" && $_->{flags} & 0x1 } @$frames; |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
621 ok($frame, 'client header timeout - PING'); |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
622 |
|
1548
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
623 # partial request header frame received (no field split), |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
624 # the rest of frame is received after client header timeout |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
625 |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
626 $s = Test::Nginx::HTTP2->new(port(8087)); |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
627 $sid = $s->new_stream({ path => '/t2.html', split => [20], split_delay => 2.1 }); |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
628 $frames = $s->read(all => [{ type => 'RST_STREAM' }]); |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
629 |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
630 TODO: { |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
631 local $TODO = 'not yet' unless $t->has_version('1.17.9'); |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
632 |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
633 ($frame) = grep { $_->{type} eq "RST_STREAM" } @$frames; |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
634 ok($frame, 'client header timeout 2'); |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
635 is($frame->{code}, 1, 'client header timeout 2 - protocol error'); |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
636 |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
637 } |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
638 |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
639 $s->h2_ping('SEE-THIS'); |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
640 $frames = $s->read(all => [{ type => 'PING' }]); |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
641 |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
642 ($frame) = grep { $_->{type} eq "PING" && $_->{flags} & 0x1 } @$frames; |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
643 ok($frame, 'client header timeout 2 - PING'); |
|
b02d0fd71638
Tests: added HTTP/2 test for HEADERS split on field boundary.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1465
diff
changeset
|
644 |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
645 # partial request body data frame received, the rest is after body timeout |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
646 |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
647 $s = Test::Nginx::HTTP2->new(port(8087)); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
648 $sid = $s->new_stream({ path => '/proxy/t2.html', body_more => 1 }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
649 $s->h2_body('TEST', { split => [10], split_delay => 2.1 }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
650 $frames = $s->read(all => [{ type => 'RST_STREAM' }]); |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
651 |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
652 ($frame) = grep { $_->{type} eq "RST_STREAM" } @$frames; |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
653 ok($frame, 'client body timeout'); |
|
841
6a401b5fa812
Tests: check timed out HTTP/2 streams for proper RST_STREAM code.
Sergey Kandaurov <pluknet@nginx.com>
parents:
840
diff
changeset
|
654 is($frame->{code}, 1, 'client body timeout - protocol error'); |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
655 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
656 $s->h2_ping('SEE-THIS'); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
657 $frames = $s->read(all => [{ type => 'PING' }]); |
|
830
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
658 |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
659 ($frame) = grep { $_->{type} eq "PING" && $_->{flags} & 0x1 } @$frames; |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
660 ok($frame, 'client body timeout - PING'); |
|
3d12316e6f41
Tests: added HTTP/2 tests for client header and body timeouts.
Sergey Kandaurov <pluknet@nginx.com>
parents:
829
diff
changeset
|
661 |
|
1647
35beaf85de72
Tests: sorted h2.t tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1589
diff
changeset
|
662 # partial request body data frame with connection close after body timeout |
|
35beaf85de72
Tests: sorted h2.t tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1589
diff
changeset
|
663 |
|
35beaf85de72
Tests: sorted h2.t tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1589
diff
changeset
|
664 $s = Test::Nginx::HTTP2->new(port(8087)); |
|
35beaf85de72
Tests: sorted h2.t tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1589
diff
changeset
|
665 $sid = $s->new_stream({ path => '/proxy/t2.html', body_more => 1 }); |
|
35beaf85de72
Tests: sorted h2.t tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1589
diff
changeset
|
666 $s->h2_body('TEST', { split => [ 12 ], abort => 1 }); |
|
35beaf85de72
Tests: sorted h2.t tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1589
diff
changeset
|
667 |
|
35beaf85de72
Tests: sorted h2.t tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1589
diff
changeset
|
668 select undef, undef, undef, 1.1; |
|
35beaf85de72
Tests: sorted h2.t tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1589
diff
changeset
|
669 undef $s; |
|
35beaf85de72
Tests: sorted h2.t tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1589
diff
changeset
|
670 |
|
852
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
671 # proxied request with logging pristine request header field (e.g., referer) |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
672 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
673 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
674 $sid = $s->new_stream({ headers => [ |
|
852
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
675 { name => ':method', value => 'GET' }, |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
676 { name => ':scheme', value => 'http' }, |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
677 { name => ':path', value => '/proxy2/' }, |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
678 { name => ':authority', value => 'localhost' }, |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
679 { name => 'referer', value => 'foo' }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
680 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
852
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
681 |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
682 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
683 is($frame->{headers}->{':status'}, 200, 'proxy with logging request headers'); |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
684 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
685 $sid = $s->new_stream(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
686 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
852
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
687 |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
688 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
689 ok($frame->{headers}, 'proxy with logging request headers - next'); |
|
e0d6ba59968f
Tests: added HTTP/2 proxy test with logging request headers.
Sergey Kandaurov <pluknet@nginx.com>
parents:
850
diff
changeset
|
690 |
| 646 | 691 # initial window size, client side |
| 692 | |
| 693 # 6.9.2. Initial Flow-Control Window Size | |
| 694 # When an HTTP/2 connection is first established, new streams are | |
| 695 # created with an initial flow-control window size of 65,535 octets. | |
| 696 # The connection flow-control window is also 65,535 octets. | |
| 697 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
698 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
699 $sid = $s->new_stream({ path => '/t1.html' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
700 $frames = $s->read(all => [{ sid => $sid, length => 2**16 - 1 }]); |
| 646 | 701 |
| 702 # with the default http2_chunk_size, data is divided into 8 data frames | |
| 703 | |
|
651
9f66f0029dca
Tests: HTTP/2 tests for http2_chunk_size directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
650
diff
changeset
|
704 @data = grep { $_->{type} eq "DATA" } @$frames; |
| 646 | 705 my $lengths = join ' ', map { $_->{length} } @data; |
| 706 is($lengths, '8192 8192 8192 8192 8192 8192 8192 8191', | |
| 707 'iws - stream blocked on initial window size'); | |
| 708 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
709 $s->h2_ping('SEE-THIS'); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
710 $frames = $s->read(all => [{ type => 'PING' }]); |
| 646 | 711 |
| 712 ($frame) = grep { $_->{type} eq "PING" && $_->{flags} & 0x1 } @$frames; | |
| 713 ok($frame, 'iws - PING not blocked'); | |
| 714 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
715 $s->h2_window(2**16, $sid); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
716 $frames = $s->read(wait => 0.2); |
| 646 | 717 is(@$frames, 0, 'iws - updated stream window'); |
| 718 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
719 $s->h2_window(2**16); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
720 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 721 |
| 722 @data = grep { $_->{type} eq "DATA" } @$frames; | |
| 723 my $sum = eval join '+', map { $_->{length} } @data; | |
| 724 is($sum, 81, 'iws - updated connection window'); | |
| 725 | |
| 726 # SETTINGS (initial window size, client side) | |
| 727 | |
| 728 # 6.9.2. Initial Flow-Control Window Size | |
| 729 # Both endpoints can adjust the initial window size for new streams by | |
| 730 # including a value for SETTINGS_INITIAL_WINDOW_SIZE in the SETTINGS | |
| 731 # frame that forms part of the connection preface. The connection | |
| 732 # flow-control window can only be changed using WINDOW_UPDATE frames. | |
| 733 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
734 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
735 $s->h2_settings(0, 0x4 => 2**17); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
736 $s->h2_window(2**17); |
| 646 | 737 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
738 $sid = $s->new_stream({ path => '/t1.html' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
739 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 740 |
| 741 @data = grep { $_->{type} eq "DATA" } @$frames; | |
| 742 $sum = eval join '+', map { $_->{length} } @data; | |
| 743 is($sum, 2**16 + 80, 'iws - increased'); | |
| 744 | |
|
1272
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
745 # INITIAL_WINDOW_SIZE duplicate settings |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
746 |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
747 # 6.5. SETTINGS |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
748 # Each parameter in a SETTINGS frame replaces any existing value for |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
749 # that parameter. Parameters are processed in the order in which they |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
750 # appear, and a receiver of a SETTINGS frame does not need to maintain |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
751 # any state other than the current value of its parameters. Therefore, |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
752 # the value of a SETTINGS parameter is the last value that is seen by a |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
753 # receiver. |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
754 |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
755 $s = Test::Nginx::HTTP2->new(); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
756 $s->h2_window(2**17); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
757 |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
758 $sid = $s->new_stream({ path => '/t1.html' }); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
759 |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
760 $frames = $s->read(all => [{ sid => $sid, length => 2**16 - 1 }]); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
761 @data = grep { $_->{type} eq "DATA" } @$frames; |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
762 $sum = eval join '+', map { $_->{length} } @data; |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
763 is($sum, 2**16 - 1, 'iws duplicate - default stream window'); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
764 |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
765 # this should effect in extra stream window octect |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
766 # $s->h2_settings(0, 0x4 => 42, 0x4 => 2**16); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
767 { |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
768 local $SIG{PIPE} = 'IGNORE'; |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
769 syswrite($s->{socket}, pack("x2C2x5nNnN", 12, 0x4, 4, 42, 4, 2**16)); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
770 } |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
771 |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
772 $frames = $s->read(all => [{ sid => $sid, length => 1 }]); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
773 @data = grep { $_->{type} eq "DATA" } @$frames; |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
774 $sum = eval join '+', map { $_->{length} } @data; |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
775 is($sum, 1, 'iws duplicate - updated stream window'); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
776 |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
777 # yet more octets to finish receiving the response |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
778 |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
779 $s->h2_settings(0, 0x4 => 2**16 + 80); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
780 |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
781 $frames = $s->read(all => [{ sid => $sid, length => 80 }]); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
782 @data = grep { $_->{type} eq "DATA" } @$frames; |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
783 $sum = eval join '+', map { $_->{length} } @data; |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
784 is($sum, 80, 'iws duplicate - updated stream window 2'); |
|
01010d9021b8
Tests: HTTP/2 INITIAL_WINDOW_SIZE duplicate settings handling.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1251
diff
changeset
|
785 |
| 646 | 786 # probe for negative available space in a flow control window |
| 787 | |
| 788 # 6.9.2. Initial Flow-Control Window Size | |
| 789 # A change to SETTINGS_INITIAL_WINDOW_SIZE can cause the available | |
| 790 # space in a flow-control window to become negative. A sender MUST | |
| 791 # track the negative flow-control window and MUST NOT send new flow- | |
| 792 # controlled frames until it receives WINDOW_UPDATE frames that cause | |
| 793 # the flow-control window to become positive. | |
| 794 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
795 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
796 $sid = $s->new_stream({ path => '/t1.html' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
797 $s->read(all => [{ sid => $sid, length => 2**16 - 1 }]); |
| 646 | 798 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
799 $s->h2_window(1); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
800 $s->h2_settings(0, 0x4 => 42); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
801 $s->h2_window(1024, $sid); |
| 646 | 802 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
803 $frames = $s->read(all => [{ type => 'SETTINGS' }]); |
| 646 | 804 |
| 805 ($frame) = grep { $_->{type} eq 'SETTINGS' } @$frames; | |
| 806 ok($frame, 'negative window - SETTINGS frame ack'); | |
| 807 is($frame->{flags}, 1, 'negative window - SETTINGS flags ack'); | |
| 808 | |
| 809 ($frame) = grep { $_->{type} ne 'SETTINGS' } @$frames; | |
| 810 is($frame, undef, 'negative window - no data'); | |
| 811 | |
| 812 # predefined window size, minus new iws settings, minus window update | |
| 813 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
814 $s->h2_window(2**16 - 1 - 42 - 1024, $sid); |
| 646 | 815 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
816 $frames = $s->read(wait => 0.2); |
| 646 | 817 is(@$frames, 0, 'zero window - no data'); |
| 818 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
819 $s->h2_window(1, $sid); |
| 646 | 820 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
821 $frames = $s->read(all => [{ sid => $sid, length => 1 }]); |
| 646 | 822 is(@$frames, 1, 'positive window'); |
|
712
649af6069976
Tests: skipped some HTTP/2 tests is case of a failed connection.
Sergey Kandaurov <pluknet@nginx.com>
parents:
707
diff
changeset
|
823 |
|
649af6069976
Tests: skipped some HTTP/2 tests is case of a failed connection.
Sergey Kandaurov <pluknet@nginx.com>
parents:
707
diff
changeset
|
824 SKIP: { |
|
649af6069976
Tests: skipped some HTTP/2 tests is case of a failed connection.
Sergey Kandaurov <pluknet@nginx.com>
parents:
707
diff
changeset
|
825 skip 'failed connection', 2 unless @$frames; |
|
649af6069976
Tests: skipped some HTTP/2 tests is case of a failed connection.
Sergey Kandaurov <pluknet@nginx.com>
parents:
707
diff
changeset
|
826 |
| 646 | 827 is(@$frames[0]->{type}, 'DATA', 'positive window - data'); |
| 828 is(@$frames[0]->{length}, 1, 'positive window - data length'); | |
| 829 | |
|
712
649af6069976
Tests: skipped some HTTP/2 tests is case of a failed connection.
Sergey Kandaurov <pluknet@nginx.com>
parents:
707
diff
changeset
|
830 } |
|
649af6069976
Tests: skipped some HTTP/2 tests is case of a failed connection.
Sergey Kandaurov <pluknet@nginx.com>
parents:
707
diff
changeset
|
831 |
|
1184
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
832 $s = Test::Nginx::HTTP2->new(); |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
833 $s->h2_window(2**30); |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
834 $s->h2_settings(0, 0x4 => 2**30); |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
835 |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
836 $sid = $s->new_stream({ path => '/frame_size/tbig.html' }); |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
837 |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
838 sleep 1; |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
839 $s->h2_settings(0, 0x5 => 2**15); |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
840 |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
841 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
842 $lengths = join ' ', map { $_->{length} } @$frames; |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
843 unlike($lengths, qr/16384 0 16384/, 'SETTINGS ack after queued DATA'); |
|
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
844 |
|
704
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
845 # ask write handler in sending large response |
|
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
846 |
|
1107
d42cc683970d
Tests: skip unsafe HTTP/2 tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1092
diff
changeset
|
847 SKIP: { |
|
d42cc683970d
Tests: skip unsafe HTTP/2 tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1092
diff
changeset
|
848 skip 'unsafe socket tests', 4 unless $ENV{TEST_NGINX_UNSAFE}; |
|
d42cc683970d
Tests: skip unsafe HTTP/2 tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1092
diff
changeset
|
849 |
|
1465
93633a10e33d
Tests: run HTTP/2 unsafe socket tests on a fresh connection.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1381
diff
changeset
|
850 $s = Test::Nginx::HTTP2->new(); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
851 $sid = $s->new_stream({ path => '/tbig.html' }); |
|
704
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
852 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
853 $s->h2_window(2**30, $sid); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
854 $s->h2_window(2**30); |
|
704
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
855 |
|
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
856 sleep 1; |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
857 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
704
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
858 |
|
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
859 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; |
|
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
860 is($frame->{headers}->{':status'}, 200, 'large response - HEADERS'); |
|
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
861 |
|
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
862 @data = grep { $_->{type} eq "DATA" } @$frames; |
|
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
863 $sum = eval join '+', map { $_->{length} } @data; |
|
723
bc4d6e2bd031
Tests: adjusted HTTP/2 test to trigger write handler in v2 module.
Sergey Kandaurov <pluknet@nginx.com>
parents:
722
diff
changeset
|
864 is($sum, 5000000, 'large response - DATA'); |
|
704
626bc3a0fdaa
Tests: SPDY and HTTP/2 write handler tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
702
diff
changeset
|
865 |
|
794
fed83003c45c
Tests: one more HTTP/2 write handler test.
Sergey Kandaurov <pluknet@nginx.com>
parents:
789
diff
changeset
|
866 # Make sure http2 write handler doesn't break a connection. |
|
fed83003c45c
Tests: one more HTTP/2 write handler test.
Sergey Kandaurov <pluknet@nginx.com>
parents:
789
diff
changeset
|
867 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
868 $sid = $s->new_stream(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
869 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
794
fed83003c45c
Tests: one more HTTP/2 write handler test.
Sergey Kandaurov <pluknet@nginx.com>
parents:
789
diff
changeset
|
870 |
|
fed83003c45c
Tests: one more HTTP/2 write handler test.
Sergey Kandaurov <pluknet@nginx.com>
parents:
789
diff
changeset
|
871 ($frame) = grep { $_->{type} eq "HEADERS" } @$frames; |
|
fed83003c45c
Tests: one more HTTP/2 write handler test.
Sergey Kandaurov <pluknet@nginx.com>
parents:
789
diff
changeset
|
872 is($frame->{headers}->{':status'}, 200, 'new stream after large response'); |
|
fed83003c45c
Tests: one more HTTP/2 write handler test.
Sergey Kandaurov <pluknet@nginx.com>
parents:
789
diff
changeset
|
873 |
|
763
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
874 # write event send timeout |
|
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
875 |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
876 $s = Test::Nginx::HTTP2->new(port(8086)); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
877 $sid = $s->new_stream({ path => '/tbig.html' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
878 $s->h2_window(2**30, $sid); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
879 $s->h2_window(2**30); |
|
763
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
880 |
|
990
eb49d29d5447
Tests: redo 892737e9fd31 without flaky send_timeout adjustments.
Sergey Kandaurov <pluknet@nginx.com>
parents:
984
diff
changeset
|
881 select undef, undef, undef, 2.1; |
|
763
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
882 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
883 $s->h2_ping('SEE-THIS'); |
|
763
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
884 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
885 $frames = $s->read(all => [{ type => 'PING' }]); |
|
763
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
886 ok(!grep ({ $_->{type} eq "PING" } @$frames), 'large response - send timeout'); |
|
2ba4058848d6
Tests: HTTP/2 test for write event timeout.
Sergey Kandaurov <pluknet@nginx.com>
parents:
762
diff
changeset
|
887 |
|
1107
d42cc683970d
Tests: skip unsafe HTTP/2 tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1092
diff
changeset
|
888 } |
|
d42cc683970d
Tests: skip unsafe HTTP/2 tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1092
diff
changeset
|
889 |
|
680
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
890 # SETTINGS_MAX_FRAME_SIZE |
|
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
891 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
892 $s = Test::Nginx::HTTP2->new(); |
|
1184
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
893 $sid = $s->new_stream({ path => '/frame_size/t1.html' }); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
894 $s->h2_window(2**18, 1); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
895 $s->h2_window(2**18); |
|
680
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
896 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
897 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
680
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
898 @data = grep { $_->{type} eq "DATA" } @$frames; |
|
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
899 is($data[0]->{length}, 2**14, 'max frame size - default'); |
|
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
900 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
901 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
902 $s->h2_settings(0, 0x5 => 2**15); |
|
1184
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
903 $sid = $s->new_stream({ path => '/frame_size/t1.html' }); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
904 $s->h2_window(2**18, 1); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
905 $s->h2_window(2**18); |
|
680
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
906 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
907 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
680
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
908 @data = grep { $_->{type} eq "DATA" } @$frames; |
|
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
909 is($data[0]->{length}, 2**15, 'max frame size - custom'); |
|
85e368105c8b
Tests: added HTTP/2 tests for SETTINGS_MAX_FRAME_SIZE.
Sergey Kandaurov <pluknet@nginx.com>
parents:
679
diff
changeset
|
910 |
|
1182
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
911 # SETTINGS_INITIAL_WINDOW_SIZE + SETTINGS_MAX_FRAME_SIZE |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
912 # Expanding available stream window should not result in emitting |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
913 # new frames before remaining SETTINGS parameters were applied. |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
914 |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
915 $s = Test::Nginx::HTTP2->new(); |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
916 $s->h2_window(2**17); |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
917 $s->h2_settings(0, 0x4 => 42); |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
918 |
|
1184
89b4bdd1346a
Tests: added HTTP/2 SETTINGS test for no ack until queued DATA.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1183
diff
changeset
|
919 $sid = $s->new_stream({ path => '/frame_size/t1.html' }); |
|
1185
368ab1d8ed8b
Tests: unbreak h2.t with aio.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1184
diff
changeset
|
920 $s->read(all => [{ sid => $sid, length => 42 }]); |
|
1182
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
921 |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
922 $s->h2_settings(0, 0x4 => 2**17, 0x5 => 2**15); |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
923 |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
924 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
925 @data = grep { $_->{type} eq "DATA" } @$frames; |
|
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
926 $lengths = join ' ', map { $_->{length} } @data; |
|
1185
368ab1d8ed8b
Tests: unbreak h2.t with aio.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1184
diff
changeset
|
927 is($lengths, '32768 32768 38', 'multiple SETTINGS'); |
|
1182
83c88a830a45
Tests: added HTTP/2 SETTINGS test with multiple parameters.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1174
diff
changeset
|
928 |
| 646 | 929 # stream multiplexing + WINDOW_UPDATE |
| 930 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
931 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
932 $sid = $s->new_stream({ path => '/t1.html' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
933 $frames = $s->read(all => [{ sid => $sid, length => 2**16 - 1 }]); |
| 646 | 934 |
| 935 @data = grep { $_->{type} eq "DATA" } @$frames; | |
| 936 $sum = eval join '+', map { $_->{length} } @data; | |
| 937 is($sum, 2**16 - 1, 'multiple - stream1 data'); | |
| 938 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
939 my $sid2 = $s->new_stream({ path => '/t1.html' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
940 $frames = $s->read(all => [{ sid => $sid2, fin => 0x4 }]); |
| 646 | 941 |
| 942 @data = grep { $_->{type} eq "DATA" } @$frames; | |
| 943 is(@data, 0, 'multiple - stream2 no data'); | |
| 944 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
945 $s->h2_window(2**17, $sid); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
946 $s->h2_window(2**17, $sid2); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
947 $s->h2_window(2**17); |
| 646 | 948 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
949 $frames = $s->read(all => [ |
| 646 | 950 { sid => $sid, fin => 1 }, |
| 951 { sid => $sid2, fin => 1 } | |
| 952 ]); | |
| 953 | |
| 954 @data = grep { $_->{type} eq "DATA" && $_->{sid} == $sid } @$frames; | |
| 955 $sum = eval join '+', map { $_->{length} } @data; | |
| 956 is($sum, 81, 'multiple - stream1 remain data'); | |
| 957 | |
| 958 @data = grep { $_->{type} eq "DATA" && $_->{sid} == $sid2 } @$frames; | |
| 959 $sum = eval join '+', map { $_->{length} } @data; | |
| 960 is($sum, 2**16 + 80, 'multiple - stream2 full data'); | |
| 961 | |
|
654
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
962 # http2_max_concurrent_streams |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
963 |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
964 $s = Test::Nginx::HTTP2->new(port(8083), pure => 1); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
965 $frames = $s->read(all => [{ type => 'SETTINGS' }]); |
|
654
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
966 |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
967 ($frame) = grep { $_->{type} eq 'SETTINGS' } @$frames; |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
968 is($frame->{3}, 1, 'http2_max_concurrent_streams SETTINGS'); |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
969 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
970 $s->h2_window(2**18); |
|
654
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
971 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
972 $sid = $s->new_stream({ path => '/t1.html' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
973 $frames = $s->read(all => [{ sid => $sid, length => 2 ** 16 - 1 }]); |
|
654
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
974 |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
975 ($frame) = grep { $_->{type} eq "HEADERS" && $_->{sid} == $sid } @$frames; |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
976 is($frame->{headers}->{':status'}, 200, 'http2_max_concurrent_streams'); |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
977 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
978 $sid2 = $s->new_stream({ path => '/t1.html' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
979 $frames = $s->read(all => [{ type => 'RST_STREAM' }]); |
|
654
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
980 |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
981 ($frame) = grep { $_->{type} eq "HEADERS" && $_->{sid} == $sid2 } @$frames; |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
982 isnt($frame->{headers}->{':status'}, 200, 'http2_max_concurrent_streams 2'); |
|
a64fe1054fb4
Tests: HTTP/2 tests for http2_max_concurrent_streams directive.
Sergey Kandaurov <pluknet@nginx.com>
parents:
653
diff
changeset
|
983 |
|
667
0247e314e991
Tests: more HTTP/2 error handling tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
662
diff
changeset
|
984 ($frame) = grep { $_->{type} eq "RST_STREAM" && $_->{sid} == $sid2 } @$frames; |
|
0247e314e991
Tests: more HTTP/2 error handling tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
662
diff
changeset
|
985 is($frame->{sid}, $sid2, 'http2_max_concurrent_streams RST_STREAM sid'); |
|
0247e314e991
Tests: more HTTP/2 error handling tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
662
diff
changeset
|
986 is($frame->{length}, 4, 'http2_max_concurrent_streams RST_STREAM length'); |
|
0247e314e991
Tests: more HTTP/2 error handling tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
662
diff
changeset
|
987 is($frame->{flags}, 0, 'http2_max_concurrent_streams RST_STREAM flags'); |
|
0247e314e991
Tests: more HTTP/2 error handling tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
662
diff
changeset
|
988 is($frame->{code}, 7, 'http2_max_concurrent_streams RST_STREAM code'); |
|
0247e314e991
Tests: more HTTP/2 error handling tests.
Sergey Kandaurov <pluknet@nginx.com>
parents:
662
diff
changeset
|
989 |
|
715
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
990 # properly skip header field that's not/never indexed from discarded streams |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
991 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
992 $sid2 = $s->new_stream({ headers => [ |
|
715
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
993 { name => ':method', value => 'GET' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
994 { name => ':scheme', value => 'http' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
995 { name => ':path', value => '/', mode => 6 }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
996 { name => ':authority', value => 'localhost' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
997 { name => 'x-foo', value => 'Foo', mode => 2 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
998 $frames = $s->read(all => [{ type => 'RST_STREAM' }]); |
|
715
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
999 |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1000 # also if split across writes |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1001 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1002 $sid2 = $s->new_stream({ split => [ 22 ], headers => [ |
|
715
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1003 { name => ':method', value => 'GET' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1004 { name => ':scheme', value => 'http' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1005 { name => ':path', value => '/', mode => 6 }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1006 { name => ':authority', value => 'localhost' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1007 { name => 'x-bar', value => 'Bar', mode => 2 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1008 $frames = $s->read(all => [{ type => 'RST_STREAM' }]); |
|
715
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1009 |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1010 # also if split across frames |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1011 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1012 $sid2 = $s->new_stream({ continuation => [ 17 ], headers => [ |
|
715
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1013 { name => ':method', value => 'GET' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1014 { name => ':scheme', value => 'http' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1015 { name => ':path', value => '/', mode => 6 }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1016 { name => ':authority', value => 'localhost' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1017 { name => 'x-baz', value => 'Baz', mode => 2 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1018 $frames = $s->read(all => [{ type => 'RST_STREAM' }]); |
|
715
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1019 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1020 $s->h2_window(2**16, $sid); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1021 $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
661
c99c30afc1c9
Tests: one more test for http2_max_concurrent_streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
660
diff
changeset
|
1022 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1023 $sid = $s->new_stream({ headers => [ |
|
715
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1024 { name => ':method', value => 'GET' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1025 { name => ':scheme', value => 'http' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1026 { name => ':path', value => '/t2.html' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1027 { name => ':authority', value => 'localhost' }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1028 # make sure that discarded streams updated dynamic table |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1029 { name => 'x-foo', value => 'Foo', mode => 0 }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1030 { name => 'x-bar', value => 'Bar', mode => 0 }, |
|
9ee52e137f3d
Tests: more HTTP/2 HPACK decoding tests with discarded streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
714
diff
changeset
|
1031 { name => 'x-baz', value => 'Baz', mode => 0 }]}); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1032 $frames = $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
661
c99c30afc1c9
Tests: one more test for http2_max_concurrent_streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
660
diff
changeset
|
1033 |
|
c99c30afc1c9
Tests: one more test for http2_max_concurrent_streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
660
diff
changeset
|
1034 ($frame) = grep { $_->{type} eq "HEADERS" && $_->{sid} == $sid } @$frames; |
|
c99c30afc1c9
Tests: one more test for http2_max_concurrent_streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
660
diff
changeset
|
1035 is($frame->{headers}->{':status'}, 200, 'http2_max_concurrent_streams 3'); |
|
c99c30afc1c9
Tests: one more test for http2_max_concurrent_streams.
Sergey Kandaurov <pluknet@nginx.com>
parents:
660
diff
changeset
|
1036 |
| 646 | 1037 |
| 1038 # some invalid cases below | |
| 1039 | |
|
728
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1040 # invalid connection preface |
|
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1041 |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
1042 $s = Test::Nginx::HTTP2->new(port(8080), preface => 'x' x 16, pure => 1); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1043 $frames = $s->read(all => [{ type => 'GOAWAY' }]); |
|
728
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1044 |
|
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1045 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; |
|
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1046 ok($frame, 'invalid preface - GOAWAY frame'); |
|
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1047 is($frame->{code}, 1, 'invalid preface - error code'); |
|
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1048 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1049 my $preface = 'PRI * HTTP/2.0' . CRLF . CRLF . 'x' x 8; |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
1050 $s = Test::Nginx::HTTP2->new(port(8080), preface => $preface, pure => 1); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1051 $frames = $s->read(all => [{ type => 'GOAWAY' }]); |
|
728
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1052 |
|
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1053 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; |
|
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1054 ok($frame, 'invalid preface 2 - GOAWAY frame'); |
|
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1055 is($frame->{code}, 1, 'invalid preface 2 - error code'); |
|
61800918f647
Tests: added HTTP/2 tests with invalid connection preface.
Sergey Kandaurov <pluknet@nginx.com>
parents:
727
diff
changeset
|
1056 |
| 646 | 1057 # GOAWAY on SYN_STREAM with even StreamID |
| 1058 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1059 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1060 $s->new_stream({ path => '/' }, 2); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1061 $frames = $s->read(all => [{ type => 'GOAWAY' }]); |
| 646 | 1062 |
| 1063 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; | |
| 1064 ok($frame, 'even stream - GOAWAY frame'); | |
| 1065 is($frame->{code}, 1, 'even stream - error code'); | |
|
669
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1066 is($frame->{last_sid}, 0, 'even stream - last stream'); |
| 646 | 1067 |
| 1068 # GOAWAY on SYN_STREAM with backward StreamID | |
| 1069 | |
|
669
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1070 # 5.1.1. Stream Identifiers |
|
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1071 # The first use of a new stream identifier implicitly closes all |
|
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1072 # streams in the "idle" state <..> with a lower-valued stream identifier. |
|
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1073 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1074 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1075 $sid = $s->new_stream({ path => '/' }, 3); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1076 $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 1077 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1078 $sid2 = $s->new_stream({ path => '/' }, 1); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1079 $frames = $s->read(all => [{ type => 'GOAWAY' }]); |
| 646 | 1080 |
| 1081 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; | |
| 1082 ok($frame, 'backward stream - GOAWAY frame'); | |
| 1083 is($frame->{code}, 1, 'backward stream - error code'); | |
|
669
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1084 is($frame->{last_sid}, $sid, 'backward stream - last stream'); |
| 646 | 1085 |
|
669
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1086 # GOAWAY on the second SYN_STREAM with same StreamID |
| 646 | 1087 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1088 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1089 $sid = $s->new_stream({ path => '/' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1090 $s->read(all => [{ sid => $sid, fin => 1 }]); |
| 646 | 1091 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1092 $sid2 = $s->new_stream({ path => '/' }, $sid); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1093 $frames = $s->read(all => [{ type => 'GOAWAY' }]); |
|
669
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1094 |
|
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1095 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; |
|
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1096 ok($frame, 'dup stream - GOAWAY frame'); |
| 646 | 1097 is($frame->{code}, 1, 'dup stream - error code'); |
|
669
0c442e551ba1
Tests: corrected HTTP/2 tests for GOAWAY.
Sergey Kandaurov <pluknet@nginx.com>
parents:
668
diff
changeset
|
1098 is($frame->{last_sid}, $sid, 'dup stream - last stream'); |
| 646 | 1099 |
|
754
84a52b6d6343
Tests: HTTP/2 regression test for incomplete HEADERS payload.
Sergey Kandaurov <pluknet@nginx.com>
parents:
748
diff
changeset
|
1100 # aborted stream with zero HEADERS payload followed by client connection close |
|
84a52b6d6343
Tests: HTTP/2 regression test for incomplete HEADERS payload.
Sergey Kandaurov <pluknet@nginx.com>
parents:
748
diff
changeset
|
1101 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1102 Test::Nginx::HTTP2->new()->new_stream({ split => [ 9 ], abort => 1 }); |
|
754
84a52b6d6343
Tests: HTTP/2 regression test for incomplete HEADERS payload.
Sergey Kandaurov <pluknet@nginx.com>
parents:
748
diff
changeset
|
1103 |
|
697
46f698a7e59c
Tests: added HTTP/2 test for unknown frame type.
Sergey Kandaurov <pluknet@nginx.com>
parents:
696
diff
changeset
|
1104 # unknown frame type |
|
46f698a7e59c
Tests: added HTTP/2 test for unknown frame type.
Sergey Kandaurov <pluknet@nginx.com>
parents:
696
diff
changeset
|
1105 |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1106 $s = Test::Nginx::HTTP2->new(); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1107 $s->h2_unknown('payload'); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1108 $s->h2_ping('SEE-THIS'); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1109 $frames = $s->read(all => [{ type => 'PING' }]); |
|
697
46f698a7e59c
Tests: added HTTP/2 test for unknown frame type.
Sergey Kandaurov <pluknet@nginx.com>
parents:
696
diff
changeset
|
1110 |
|
46f698a7e59c
Tests: added HTTP/2 test for unknown frame type.
Sergey Kandaurov <pluknet@nginx.com>
parents:
696
diff
changeset
|
1111 ($frame) = grep { $_->{type} eq "PING" } @$frames; |
|
46f698a7e59c
Tests: added HTTP/2 test for unknown frame type.
Sergey Kandaurov <pluknet@nginx.com>
parents:
696
diff
changeset
|
1112 is($frame->{value}, 'SEE-THIS', 'unknown frame type'); |
|
46f698a7e59c
Tests: added HTTP/2 test for unknown frame type.
Sergey Kandaurov <pluknet@nginx.com>
parents:
696
diff
changeset
|
1113 |
|
755
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
1114 # graceful shutdown with stream waiting on HEADERS payload |
|
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
1115 |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
1116 my $grace = Test::Nginx::HTTP2->new(port(8084)); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1117 $grace->new_stream({ split => [ 9 ], abort => 1 }); |
|
755
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
1118 |
|
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
1119 # graceful shutdown with stream waiting on WINDOW_UPDATE |
|
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
1120 |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
1121 my $grace2 = Test::Nginx::HTTP2->new(port(8084)); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1122 $sid = $grace2->new_stream({ path => '/t1.html' }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1123 $grace2->read(all => [{ sid => $sid, length => 2**16 - 1 }]); |
|
755
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
1124 |
|
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
1125 # graceful shutdown waiting on incomplete request body DATA frames |
|
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
1126 |
|
974
882267679006
Tests: simplified parallel modifications in tests.
Andrey Zelenkov <zelenkov@nginx.com>
parents:
952
diff
changeset
|
1127 my $grace3 = Test::Nginx::HTTP2->new(port(8085)); |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1128 $sid = $grace3->new_stream({ path => '/proxy2/t2.html', body_more => 1 }); |
|
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1129 $grace3->h2_body('TEST', { body_more => 1 }); |
|
755
f95aa716624e
Tests: HTTP/2 tests for alerts on graceful shutdown.
Sergey Kandaurov <pluknet@nginx.com>
parents:
754
diff
changeset
|
1130 |
|
1065
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1131 # GOAWAY without awaiting active streams, further streams ignored |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1132 |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1133 $s = Test::Nginx::HTTP2->new(port(8080)); |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1134 $sid = $s->new_stream({ path => '/t1.html' }); |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1135 $s->read(all => [{ sid => $sid, length => 2**16 - 1 }]); |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1136 |
|
1206
c99c1f43cb15
Tests: reload() introduced in Test::Nginx.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1185
diff
changeset
|
1137 $t->reload(); |
|
1065
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1138 |
|
1066
23418577df58
Tests: tweak HTTP/2 GOAWAY test with no new stream after reload.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1065
diff
changeset
|
1139 $frames = $s->read(all => [{ type => 'GOAWAY' }]); |
|
23418577df58
Tests: tweak HTTP/2 GOAWAY test with no new stream after reload.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1065
diff
changeset
|
1140 |
|
23418577df58
Tests: tweak HTTP/2 GOAWAY test with no new stream after reload.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1065
diff
changeset
|
1141 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; |
|
23418577df58
Tests: tweak HTTP/2 GOAWAY test with no new stream after reload.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1065
diff
changeset
|
1142 is($frame->{last_sid}, $sid, 'GOAWAY with active stream - last sid'); |
|
23418577df58
Tests: tweak HTTP/2 GOAWAY test with no new stream after reload.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1065
diff
changeset
|
1143 |
|
1065
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1144 $sid2 = $s->new_stream(); |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1145 $frames = $s->read(all => [{ sid => $sid2, fin => 0x4 }], wait => 0.5); |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1146 |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1147 ($frame) = grep { $_->{type} eq 'HEADERS' } @$frames; |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1148 is($frame, undef, 'GOAWAY with active stream - no new stream'); |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1149 |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1150 $s->h2_window(100, $sid); |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1151 $s->h2_window(100); |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1152 $frames = $s->read(all => [{ sid => $sid, fin => 0x1 }]); |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1153 |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1154 @data = grep { $_->{type} eq "DATA" && $_->{sid} == $sid } @$frames; |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1155 $sum = eval join '+', map { $_->{length} } @data; |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1156 is($sum, 81, 'GOAWAY with active stream - active stream DATA after GOAWAY'); |
|
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1157 |
|
990
eb49d29d5447
Tests: redo 892737e9fd31 without flaky send_timeout adjustments.
Sergey Kandaurov <pluknet@nginx.com>
parents:
984
diff
changeset
|
1158 # GOAWAY - force closing a connection by server with idle or active streams |
|
eb49d29d5447
Tests: redo 892737e9fd31 without flaky send_timeout adjustments.
Sergey Kandaurov <pluknet@nginx.com>
parents:
984
diff
changeset
|
1159 |
|
1065
2d4343a47c6d
Tests: more HTTP/2 GOAWAY tests with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
1020
diff
changeset
|
1160 $s = Test::Nginx::HTTP2->new(); |
|
990
eb49d29d5447
Tests: redo 892737e9fd31 without flaky send_timeout adjustments.
Sergey Kandaurov <pluknet@nginx.com>
parents:
984
diff
changeset
|
1161 $sid = $s->new_stream(); |
|
eb49d29d5447
Tests: redo 892737e9fd31 without flaky send_timeout adjustments.
Sergey Kandaurov <pluknet@nginx.com>
parents:
984
diff
changeset
|
1162 $s->read(all => [{ sid => $sid, fin => 1 }]); |
|
eb49d29d5447
Tests: redo 892737e9fd31 without flaky send_timeout adjustments.
Sergey Kandaurov <pluknet@nginx.com>
parents:
984
diff
changeset
|
1163 |
|
eb49d29d5447
Tests: redo 892737e9fd31 without flaky send_timeout adjustments.
Sergey Kandaurov <pluknet@nginx.com>
parents:
984
diff
changeset
|
1164 my $active = Test::Nginx::HTTP2->new(port(8086)); |
|
995
35739834ecd9
Tests: fixed HTTP/2 GOAWAY test for connection with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
990
diff
changeset
|
1165 $sid = $active->new_stream({ path => '/t1.html' }); |
|
35739834ecd9
Tests: fixed HTTP/2 GOAWAY test for connection with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
990
diff
changeset
|
1166 $active->read(all => [{ sid => $sid, length => 2**16 - 1 }]); |
|
990
eb49d29d5447
Tests: redo 892737e9fd31 without flaky send_timeout adjustments.
Sergey Kandaurov <pluknet@nginx.com>
parents:
984
diff
changeset
|
1167 |
| 646 | 1168 $t->stop(); |
| 1169 | |
|
948
4dc302d8e04f
Tests: changed HTTP2 package to act as a class.
Sergey Kandaurov <pluknet@nginx.com>
parents:
945
diff
changeset
|
1170 $frames = $s->read(all => [{ type => 'GOAWAY' }]); |
| 646 | 1171 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; |
|
984
892737e9fd31
Tests: added HTTP/2 GOAWAY test for connection with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
974
diff
changeset
|
1172 ok($frame, 'GOAWAY on connection close - idle stream'); |
|
892737e9fd31
Tests: added HTTP/2 GOAWAY test for connection with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
974
diff
changeset
|
1173 |
|
892737e9fd31
Tests: added HTTP/2 GOAWAY test for connection with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
974
diff
changeset
|
1174 $frames = $active->read(all => [{ type => 'GOAWAY' }]); |
|
892737e9fd31
Tests: added HTTP/2 GOAWAY test for connection with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
974
diff
changeset
|
1175 ($frame) = grep { $_->{type} eq "GOAWAY" } @$frames; |
|
892737e9fd31
Tests: added HTTP/2 GOAWAY test for connection with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
974
diff
changeset
|
1176 ok($frame, 'GOAWAY on connection close - active stream'); |
|
892737e9fd31
Tests: added HTTP/2 GOAWAY test for connection with active stream.
Sergey Kandaurov <pluknet@nginx.com>
parents:
974
diff
changeset
|
1177 |
| 646 | 1178 ############################################################################### |
| 1179 | |
|
647
4e36550410b3
Tests: h2.t fixes for older perl versions, and gzip test.
Sergey Kandaurov <pluknet@nginx.com>
parents:
646
diff
changeset
|
1180 sub gunzip_like { |
|
4e36550410b3
Tests: h2.t fixes for older perl versions, and gzip test.
Sergey Kandaurov <pluknet@nginx.com>
parents:
646
diff
changeset
|
1181 my ($in, $re, $name) = @_; |
| 646 | 1182 |
| 1183 SKIP: { | |
| 1184 eval { require IO::Uncompress::Gunzip; }; | |
| 1185 Test::More::skip( | |
| 1186 "IO::Uncompress::Gunzip not installed", 1) if $@; | |
| 1187 | |
| 1188 my $out; | |
| 1189 | |
| 1190 IO::Uncompress::Gunzip::gunzip(\$in => \$out); | |
| 1191 | |
|
647
4e36550410b3
Tests: h2.t fixes for older perl versions, and gzip test.
Sergey Kandaurov <pluknet@nginx.com>
parents:
646
diff
changeset
|
1192 like($out, $re, $name); |
| 646 | 1193 } |
| 1194 } | |
| 1195 | |
| 1196 ############################################################################### |