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