aboutsummaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
authorLoïc Hoguin <[email protected]>2018-03-07 18:27:19 +0100
committerLoïc Hoguin <[email protected]>2018-03-12 16:52:02 +0100
commita89732e8e0fac2b2265007a11c05d4d0f6e6b1b0 (patch)
treeedd3a0c1248df23f3b65900d4164abcc7b4db5e1
parente4f1c332a3027b236ad07b25ffb033a11b195855 (diff)
downloadcowboy-a89732e8e0fac2b2265007a11c05d4d0f6e6b1b0.tar.gz
cowboy-a89732e8e0fac2b2265007a11c05d4d0f6e6b1b0.tar.bz2
cowboy-a89732e8e0fac2b2265007a11c05d4d0f6e6b1b0.zip
Initial work on the sys_SUITE
There's already tests failing and quite some refactoring to be done to make some things easier to test or fix issues.
-rw-r--r--test/handlers/long_polling_sys_h.erl23
-rw-r--r--test/sys_SUITE.erl1079
2 files changed, 1102 insertions, 0 deletions
diff --git a/test/handlers/long_polling_sys_h.erl b/test/handlers/long_polling_sys_h.erl
new file mode 100644
index 0000000..7745d8c
--- /dev/null
+++ b/test/handlers/long_polling_sys_h.erl
@@ -0,0 +1,23 @@
+%% This module implements a loop handler that does nothing
+%% and expects a crash to happen.
+
+-module(long_polling_sys_h).
+
+-export([init/2]).
+-export([info/3]).
+-export([terminate/3]).
+
+init(Req, _) ->
+ process_flag(trap_exit, true),
+ erlang:send_after(500, self(), timeout),
+ {cowboy_loop, Req, undefined, hibernate}.
+
+info(timeout, Req, State) ->
+ %% Send an unused status code to make sure there's no
+ %% conflict with whatever Cowboy may send itself.
+ {ok, cowboy_req:reply(<<"299 OK!">>, Req), State};
+info(_, Req, State) ->
+ {ok, Req, State}.
+
+terminate({crash, _, _}, _, _) ->
+ ok.
diff --git a/test/sys_SUITE.erl b/test/sys_SUITE.erl
new file mode 100644
index 0000000..9c14145
--- /dev/null
+++ b/test/sys_SUITE.erl
@@ -0,0 +1,1079 @@
+%% Copyright (c) 2018, Loïc Hoguin <[email protected]>
+%%
+%% Permission to use, copy, modify, and/or distribute this software for any
+%% purpose with or without fee is hereby granted, provided that the above
+%% copyright notice and this permission notice appear in all copies.
+%%
+%% THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+%% WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+%% MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+%% ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+%% WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+%% ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+%% OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+-module(sys_SUITE).
+-compile(export_all).
+-compile(nowarn_export_all).
+
+-import(ct_helper, [config/2]).
+-import(ct_helper, [doc/1]).
+-import(cowboy_test, [gun_open/1]).
+
+all() ->
+ [{group, sys}].
+
+groups() ->
+ [{sys, [parallel], ct_helper:all(?MODULE)}].
+
+init_per_suite(Config) ->
+ ProtoOpts = #{
+ env => #{dispatch => init_dispatch(Config)}
+ },
+ %% Clear listener.
+ {ok, _} = cowboy:start_clear(clear, [{port, 0}], ProtoOpts),
+ ClearPort = ranch:get_port(clear),
+ %% TLS listener.
+ TLSOpts = ct_helper:get_certs_from_ets(),
+ {ok, _} = cowboy:start_tls(tls, TLSOpts ++ [{port, 0}], ProtoOpts),
+ TLSPort = ranch:get_port(tls),
+ [
+ {clear_port, ClearPort},
+ %% @todo Add the h2 stuff to the opts.
+ {tls_opts, TLSOpts},
+ {tls_port, TLSPort}
+ |Config].
+
+end_per_suite(_) ->
+ ok = cowboy:stop_listener(clear),
+ ok = cowboy:stop_listener(tls).
+
+init_dispatch(_) ->
+ cowboy_router:compile([{"[...]", [
+ {"/", hello_h, []},
+ {"/loop", long_polling_sys_h, []},
+ {"/ws", ws_echo, []}
+ ]}]).
+
+do_get_remote_pid_tcp(Socket) when is_port(Socket) ->
+ do_get_remote_pid_tcp(inet:sockname(Socket));
+do_get_remote_pid_tcp(SockName) ->
+ AllPorts = [{P, erlang:port_info(P)} || P <- erlang:ports()],
+ [Pid] = [
+ proplists:get_value(connected, I)
+ || {P, I} <- AllPorts,
+ I =/= undefined,
+ proplists:get_value(name, I) =:= "tcp_inet",
+ inet:peername(P) =:= SockName],
+ Pid.
+
+-include_lib("ssl/src/ssl_connection.hrl").
+
+do_get_remote_pid_tls(Socket) ->
+ %% This gives us the pid of the sslsocket process.
+ %% We must introspect this process in order to retrieve the connection pid.
+ TLSPid = do_get_remote_pid_tcp(ssl:sockname(Socket)),
+ {_, #state{user_application={_, UserPid}}} = sys:get_state(TLSPid),
+ UserPid.
+
+do_get_parent_pid(Pid) ->
+ {_, ProcDict} = process_info(Pid, dictionary),
+ {_, [Parent|_]} = lists:keyfind('$ancestors', 1, ProcDict),
+ Parent.
+
+%% proc_lib.
+
+proc_lib_initial_call_clear(Config) ->
+ doc("Confirm that clear connection processes are started using proc_lib."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config), []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ {cowboy_clear, _, _} = proc_lib:initial_call(Pid),
+ ok.
+
+proc_lib_initial_call_tls(Config) ->
+ doc("Confirm that TLS connection processes are started using proc_lib."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config), config(tls_opts, Config)),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ {cowboy_tls, _, _} = proc_lib:initial_call(Pid),
+ ok.
+
+%% System messages.
+%%
+%% Plain system messages are received as {system, From, Msg}.
+%% The content and meaning of this message are not interpreted by
+%% the receiving process module. When a system message is received,
+%% function handle_system_msg/6 is called to handle the request.
+
+%% @todo The flush/0 function in cowboy_http needs to be fixed
+%% so that it doesn't eat up system messages. It should only
+%% flush messages that are specific to cowboy_http.
+
+%% @todo The cowboy_websocket module needs to have the functions
+%% handler_loop and websocket_payload_loop merged into one.
+
+bad_system_from_h1(Config) ->
+ doc("h1: Sending a system message with a bad From value results in a process crash."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config), [{active, false}]),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ ct_helper_error_h:ignore(Pid, gen, reply, 2),
+ Pid ! {system, bad, get_state},
+ {error, closed} = gen_tcp:recv(Socket, 0, 1000),
+ false = is_process_alive(Pid),
+ ok.
+
+bad_system_from_h2(Config) ->
+ doc("h2: Sending a system message with a bad From value results in a process crash."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Skip the SETTINGS frame.
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ ct_helper_error_h:ignore(Pid, gen, reply, 2),
+ Pid ! {system, bad, get_state},
+ {error, closed} = ssl:recv(Socket, 0, 1000),
+ false = is_process_alive(Pid),
+ ok.
+
+bad_system_from_ws(Config) ->
+ doc("ws: Sending a system message with a bad From value results in a process crash."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ ct_helper_error_h:ignore(Pid, gen, reply, 2),
+ Pid ! {system, bad, get_state},
+ {error, closed} = gen_tcp:recv(Socket, 0, 1000),
+ false = is_process_alive(Pid),
+ ok.
+
+bad_system_from_loop(Config) ->
+ doc("loop: Sending a system message with a bad From value results in a process crash."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config), [{active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ SupPid = do_get_remote_pid_tcp(Socket),
+ [{_, Pid, _, _}] = supervisor:which_children(SupPid),
+ ct_helper_error_h:ignore(Pid, gen, reply, 2),
+ Pid ! {system, bad, get_state},
+ {ok, "HTTP/1.1 500 "} = gen_tcp:recv(Socket, 13, 1000),
+ false = is_process_alive(Pid),
+ ok.
+
+bad_system_message_h1(Config) ->
+ doc("h1: Sending a system message with a bad Request value results in an error."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config), []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ Ref = make_ref(),
+ Pid ! {system, {self(), Ref}, hello},
+ receive
+ {Ref, {error, {unknown_system_msg, hello}}} ->
+ ok
+ after 1000 ->
+ error(timeout)
+ end.
+
+bad_system_message_h2(Config) ->
+ doc("h2: Sending a system message with a bad Request value results in an error."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Skip the SETTINGS frame.
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ Ref = make_ref(),
+ Pid ! {system, {self(), Ref}, hello},
+ receive
+ {Ref, {error, {unknown_system_msg, hello}}} ->
+ ok
+ after 1000 ->
+ error(timeout)
+ end.
+
+bad_system_message_ws(Config) ->
+ doc("ws: Sending a system message with a bad Request value results in an error."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ Ref = make_ref(),
+ Pid ! {system, {self(), Ref}, hello},
+ receive
+ {Ref, {error, {unknown_system_msg, hello}}} ->
+ ok
+ after 1000 ->
+ error(timeout)
+ end.
+
+bad_system_message_loop(Config) ->
+ doc("loop: Sending a system message with a bad Request value results in an error."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config), [{active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ SupPid = do_get_remote_pid_tcp(Socket),
+ [{_, Pid, _, _}] = supervisor:which_children(SupPid),
+ Ref = make_ref(),
+ Pid ! {system, {self(), Ref}, hello},
+ receive
+ {Ref, {error, {unknown_system_msg, hello}}} ->
+ ok
+ after 1000 ->
+ error(timeout)
+ end.
+
+good_system_message_h1(Config) ->
+ doc("h1: System messages are handled properly."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config), []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ Ref = make_ref(),
+ Pid ! {system, {self(), Ref}, get_state},
+ receive
+ {Ref, Result} when element(1, Result) =/= error ->
+ ok
+ after 1000 ->
+ error(timeout)
+ end.
+
+good_system_message_h2(Config) ->
+ doc("h2: System messages are handled properly."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Skip the SETTINGS frame.
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ Ref = make_ref(),
+ Pid ! {system, {self(), Ref}, get_state},
+ receive
+ {Ref, Result} when element(1, Result) =/= error ->
+ ok
+ after 1000 ->
+ error(timeout)
+ end.
+
+good_system_message_ws(Config) ->
+ doc("ws: Sending a system message with a bad Request value results in an error."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ Ref = make_ref(),
+ Pid ! {system, {self(), Ref}, get_state},
+ receive
+ {Ref, Result} when element(1, Result) =/= error ->
+ ok
+ after 1000 ->
+ error(timeout)
+ end.
+
+good_system_message_loop(Config) ->
+ doc("loop: Sending a system message with a bad Request value results in an error."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config), [{active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ SupPid = do_get_remote_pid_tcp(Socket),
+ [{_, Pid, _, _}] = supervisor:which_children(SupPid),
+ Ref = make_ref(),
+ Pid ! {system, {self(), Ref}, get_state},
+ receive
+ {Ref, Result} when element(1, Result) =/= error ->
+ ok
+ after 1000 ->
+ error(timeout)
+ end.
+
+%% 'EXIT'.
+%%
+%% Shutdown messages. If the process traps exits, it must be able
+%% to handle a shutdown request from its parent, the supervisor.
+%% The message {'EXIT', Parent, Reason} from the parent is an order
+%% to terminate. The process must terminate when this message is
+%% received, normally with the same Reason as Parent.
+
+trap_exit_parent_exit_h1(Config) ->
+ doc("h1: A process trapping exits must stop when receiving "
+ "an 'EXIT' message from its parent."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [{active, false}]),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ Parent = do_get_parent_pid(Pid),
+ Pid ! {'EXIT', Parent, shutdown},
+ {error, closed} = gen_tcp:recv(Socket, 0, 1000),
+ false = is_process_alive(Pid),
+ ok.
+
+trap_exit_parent_exit_h2(Config) ->
+ doc("h2: A process trapping exits must stop when receiving "
+ "an 'EXIT' message from its parent."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Skip the SETTINGS frame.
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ Parent = do_get_parent_pid(Pid),
+ Pid ! {'EXIT', Parent, shutdown},
+ {error, closed} = ssl:recv(Socket, 0, 1000),
+ false = is_process_alive(Pid),
+ ok.
+
+trap_exit_parent_exit_ws(Config) ->
+ doc("ws: A process trapping exits must stop when receiving "
+ "an 'EXIT' message from its parent."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ Parent = do_get_parent_pid(Pid),
+ Pid ! {'EXIT', Parent, shutdown},
+ {error, closed} = gen_tcp:recv(Socket, 0, 1000),
+ false = is_process_alive(Pid),
+ ok.
+
+trap_exit_parent_exit_loop(Config) ->
+ doc("loop: A process trapping exits must stop when receiving "
+ "an 'EXIT' message from its parent."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config), [{active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ Parent = do_get_remote_pid_tcp(Socket),
+ [{_, Pid, _, _}] = supervisor:which_children(Parent),
+ Pid ! {'EXIT', Parent, shutdown},
+ %% We're getting a 500 because the process exited in an unexpected way
+ %% from Cowboy's point of view.
+ {ok, "HTTP/1.1 500 "} = gen_tcp:recv(Socket, 13, 1000),
+ false = is_process_alive(Pid),
+ ok.
+
+trap_exit_other_exit_h1(Config) ->
+ doc("h1: A process trapping exits must ignore "
+ "'EXIT' messages from unknown processes."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [{active, false}]),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ Pid ! {'EXIT', self(), shutdown},
+ ok = gen_tcp:send(Socket,
+ "GET / HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ {ok, "HTTP/1.1 200 "} = gen_tcp:recv(Socket, 13, 1000),
+ true = is_process_alive(Pid),
+ ok.
+
+trap_exit_other_exit_h2(Config) ->
+ doc("h2: A process trapping exits must ignore "
+ "'EXIT' messages from unknown processes."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Do the handshake.
+ ok = ssl:send(Socket, ["PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", cow_http2:settings(#{})]),
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ ok = ssl:send(Socket, cow_http2:settings_ack()),
+ {ok, << 0:24, 4:8, 1:8, 0:32 >>} = ssl:recv(Socket, 9, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ Pid ! {'EXIT', self(), shutdown},
+ %% Send a HEADERS frame as a request.
+ {HeadersBlock, _} = cow_hpack:encode([
+ {<<":method">>, <<"GET">>},
+ {<<":scheme">>, <<"https">>},
+ {<<":authority">>, <<"localhost">>}, %% @todo Correct port number.
+ {<<":path">>, <<"/">>}
+ ]),
+ ok = ssl:send(Socket, cow_http2:headers(1, fin, HeadersBlock)),
+ %% Receive a HEADERS frame as a response.
+ {ok, << _:24, 1:8, _:40 >>} = ssl:recv(Socket, 9, 6000),
+ true = is_process_alive(Pid),
+ ok.
+
+trap_exit_other_exit_ws(Config) ->
+ doc("ws: A process trapping exits must ignore "
+ "'EXIT' messages from unknown processes."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ Parent = do_get_parent_pid(Pid),
+ Pid ! {'EXIT', Parent, shutdown},
+ %% The process stays alive.
+ {error, timeout} = gen_tcp:recv(Socket, 0, 1000),
+ true = is_process_alive(Pid),
+ ok.
+
+trap_exit_other_exit_loop(Config) ->
+ doc("loop: A process trapping exits must ignore "
+ "'EXIT' messages from unknown processes."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config), [{active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ Parent = do_get_remote_pid_tcp(Socket),
+ [{_, Pid, _, _}] = supervisor:which_children(Parent),
+ Pid ! {'EXIT', Parent, shutdown},
+ %% The process stays alive.
+ {ok, "HTTP/1.1 299 "} = gen_tcp:recv(Socket, 13, 1000),
+ true = is_process_alive(Pid),
+ ok.
+
+%% get_modules.
+%%
+%% If the modules used to implement the process change dynamically
+%% during runtime, the process must understand one more message.
+%% An example is the gen_event processes. The message is
+%% {_Label, {From, Ref}, get_modules}. The reply to this message is
+%% From ! {Ref, Modules}, where Modules is a list of the currently
+%% active modules in the process.
+%%
+%% For example:
+%%
+%% 1> application:start(sasl).
+%% ok
+%% 2> gen:call(alarm_handler, self(), get_modules).
+%% {ok,[alarm_handler]}
+%% 3> whereis(alarm_handler) ! {'$gen', {self(), make_ref()}, get_modules}.
+%% {'$gen',{<0.61.0>,#Ref<0.2900144977.374865921.142102>},
+%% get_modules}
+%% 4> flush().
+%% Shell got {#Ref<0.2900144977.374865921.142102>,[alarm_handler]}
+%%
+%% Cowboy's connection processes change dynamically: it starts with
+%% cowboy_clear or cowboy_tls, then becomes cowboy_http or cowboy_http2
+%% and may then become or involve cowboy_websocket. On top of that
+%% it has various callback modules in the form of stream handlers.
+
+%% @todo
+%get_modules_h1(Config) ->
+%get_modules_h2(Config) ->
+%get_modules_ws(Config) ->
+%get_modules_loop(Config) ->
+
+%% @todo On top of this we will want to make the supervisor calls
+%% in ranch_conns_sup return dynamic instead of a list of modules.
+
+%% sys.
+
+%% @todo sys:change_code/4,5 and Module:system_code_change/4
+%sys_change_code_h1(Config) ->
+%sys_change_code_h2(Config) ->
+%sys_change_code_ws(Config) ->
+%sys_change_code_loop(Config) ->
+
+%% @todo sys:get_state/1,2 and Module:system_get_state/1
+%sys_get_state_h1(Config) ->
+%sys_get_state_h2(Config) ->
+%sys_get_state_ws(Config) ->
+%sys_get_state_loop(Config) ->
+
+%% @todo sys:get_status/1,2
+%sys_get_status_h1(Config) ->
+%sys_get_status_h2(Config) ->
+%sys_get_status_ws(Config) ->
+%sys_get_status_loop(Config) ->
+
+%% @todo sys:replace_state/2,3 and Module:replace_state/2
+%sys_replace_state_h1(Config) ->
+%sys_replace_state_h2(Config) ->
+%sys_replace_state_ws(Config) ->
+%sys_replace_state_loop(Config) ->
+
+%% @todo sys:resume/1,2 and sys:suspend/1,2 and Module:system_continue/3
+%sys_suspend_and_resume_h1(Config) ->
+%sys_suspend_and_resume_h2(Config) ->
+%sys_suspend_and_resume_ws(Config) ->
+%sys_suspend_and_resume_loop(Config) ->
+
+%% @todo sys:terminate/2,3 and Module:system_terminate/4
+%sys_terminate_h1(Config) ->
+%sys_terminate_h2(Config) ->
+%sys_terminate_ws(Config) ->
+%sys_terminate_loop(Config) ->
+
+%% @todo Debugging functionality from sys.
+%%
+%% The functions make references to a debug structure.
+%% The debug structure is a list of dbg_opt(), which is
+%% an internal data type used by function handle_system_msg/6.
+%% No debugging is performed if it is an empty list.
+%%
+%% Cowboy currently does not implement sys debugging.
+%%
+%% The following functions are concerned:
+%%
+%% * sys:install/2,3
+%% * sys:log/2,3
+%% * sys:log_to_file/2,3
+%% * sys:no_debug/1,2
+%% * sys:remove/2,3
+%% * sys:statistics/2,3
+%% * sys:trace/2,3
+%% * call debug_options/1
+%% * call get_debug/3
+%% * call handle_debug/4
+%% * call print_log/1
+
+%% supervisor.
+%%
+%% The connection processes act as supervisors by default
+%% so they must handle the supervisor messages.
+
+%% supervisor:count_children/1.
+
+supervisor_count_children_h1(Config) ->
+ doc("h1: The function supervisor:count_children/1 must work."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [{active, false}]),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% No request was sent so there's no children.
+ Counts1 = supervisor:count_children(Pid),
+ 1 = proplists:get_value(specs, Counts1),
+ 0 = proplists:get_value(active, Counts1),
+ 0 = proplists:get_value(supervisors, Counts1),
+ 0 = proplists:get_value(workers, Counts1),
+ %% Send a request, observe that a children exists.
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ Counts2 = supervisor:count_children(Pid),
+ 1 = proplists:get_value(specs, Counts2),
+ 1 = proplists:get_value(active, Counts2),
+ 0 = proplists:get_value(supervisors, Counts2),
+ 1 = proplists:get_value(workers, Counts2),
+ ok.
+
+supervisor_count_children_h2(Config) ->
+ doc("h2: The function supervisor:count_children/1 must work."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Do the handshake.
+ ok = ssl:send(Socket, ["PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", cow_http2:settings(#{})]),
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ ok = ssl:send(Socket, cow_http2:settings_ack()),
+ {ok, << 0:24, 4:8, 1:8, 0:32 >>} = ssl:recv(Socket, 9, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ %% No request was sent so there's no children.
+ Counts1 = supervisor:count_children(Pid),
+ 1 = proplists:get_value(specs, Counts1),
+ 0 = proplists:get_value(active, Counts1),
+ 0 = proplists:get_value(supervisors, Counts1),
+ 0 = proplists:get_value(workers, Counts1),
+ %% Send a request, observe that a children exists.
+ {HeadersBlock, _} = cow_hpack:encode([
+ {<<":method">>, <<"GET">>},
+ {<<":scheme">>, <<"https">>},
+ {<<":authority">>, <<"localhost">>}, %% @todo Correct port number.
+ {<<":path">>, <<"/loop">>}
+ ]),
+ ok = ssl:send(Socket, cow_http2:headers(1, fin, HeadersBlock)),
+ timer:sleep(100),
+ Counts2 = supervisor:count_children(Pid),
+ 1 = proplists:get_value(specs, Counts2),
+ 1 = proplists:get_value(active, Counts2),
+ 0 = proplists:get_value(supervisors, Counts2),
+ 1 = proplists:get_value(workers, Counts2),
+ ok.
+
+supervisor_count_children_ws(Config) ->
+ doc("ws: The function supervisor:count_children/1 must work. "
+ "Websocket connections never have children."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% We use gen_server:call directly because the supervisor:count_children
+ %% function has a timeout of infinity.
+ %% @todo This can be changed to supervisor:count_children/1 once it is fixed.
+ Counts = gen_server:call(Pid, count_children, 1000),
+ 1 = proplists:get_value(specs, Counts),
+ 0 = proplists:get_value(active, Counts),
+ 0 = proplists:get_value(supervisors, Counts),
+ 0 = proplists:get_value(workers, Counts),
+ ok.
+
+%% supervisor:delete_child/2.
+
+supervisor_delete_child_not_found_h1(Config) ->
+ doc("h1: The function supervisor:delete_child/2 must return {error, not_found}."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [{active, false}]),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% When no children exist.
+ {error, not_found} = supervisor:delete_child(Pid, cowboy_http),
+ %% When a child exists.
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ {error, not_found} = supervisor:delete_child(Pid, cowboy_http),
+ ok.
+
+supervisor_delete_child_not_found_h2(Config) ->
+ doc("h2: The function supervisor:delete_child/2 must return {error, not_found}."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Do the handshake.
+ ok = ssl:send(Socket, ["PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", cow_http2:settings(#{})]),
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ ok = ssl:send(Socket, cow_http2:settings_ack()),
+ {ok, << 0:24, 4:8, 1:8, 0:32 >>} = ssl:recv(Socket, 9, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ %% When no children exist.
+ {error, not_found} = supervisor:delete_child(Pid, cowboy_http2),
+ %% When a child exists.
+ {HeadersBlock, _} = cow_hpack:encode([
+ {<<":method">>, <<"GET">>},
+ {<<":scheme">>, <<"https">>},
+ {<<":authority">>, <<"localhost">>}, %% @todo Correct port number.
+ {<<":path">>, <<"/loop">>}
+ ]),
+ ok = ssl:send(Socket, cow_http2:headers(1, fin, HeadersBlock)),
+ timer:sleep(100),
+ {error, not_found} = supervisor:delete_child(Pid, cowboy_http2),
+ ok.
+
+supervisor_delete_child_not_found_ws(Config) ->
+ doc("ws: The function supervisor:delete_child/2 must return {error, not_found}."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% We use gen_server:call directly because the supervisor:delete_child
+ %% function has a timeout of infinity.
+ %% @todo This can be changed to supervisor:delete_child/2 once it is fixed.
+ {error, not_found} = gen_server:call(Pid, {delete_child, cowboy_websocket}, 1000),
+ ok.
+
+%% supervisor:get_childspec/2.
+
+supervisor_get_childspec_not_found_h1(Config) ->
+ doc("h1: The function supervisor:get_childspec/2 must return {error, not_found}."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [{active, false}]),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% When no children exist.
+ {error, not_found} = supervisor:get_childspec(Pid, cowboy_http),
+ %% When a child exists.
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ {error, not_found} = supervisor:get_childspec(Pid, cowboy_http),
+ ok.
+
+supervisor_get_childspec_not_found_h2(Config) ->
+ doc("h2: The function supervisor:get_childspec/2 must return {error, not_found}."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Do the handshake.
+ ok = ssl:send(Socket, ["PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", cow_http2:settings(#{})]),
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ ok = ssl:send(Socket, cow_http2:settings_ack()),
+ {ok, << 0:24, 4:8, 1:8, 0:32 >>} = ssl:recv(Socket, 9, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ %% When no children exist.
+ {error, not_found} = supervisor:get_childspec(Pid, cowboy_http2),
+ %% When a child exists.
+ {HeadersBlock, _} = cow_hpack:encode([
+ {<<":method">>, <<"GET">>},
+ {<<":scheme">>, <<"https">>},
+ {<<":authority">>, <<"localhost">>}, %% @todo Correct port number.
+ {<<":path">>, <<"/loop">>}
+ ]),
+ ok = ssl:send(Socket, cow_http2:headers(1, fin, HeadersBlock)),
+ timer:sleep(100),
+ {error, not_found} = supervisor:get_childspec(Pid, cowboy_http2),
+ ok.
+
+supervisor_get_childspec_not_found_ws(Config) ->
+ doc("ws: The function supervisor:get_childspec/2 must return {error, not_found}."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% We use gen_server:call directly because the supervisor:get_childspec
+ %% function has a timeout of infinity.
+ %% @todo This can be changed to supervisor:get_childspec/2 once it is fixed.
+ {error, not_found} = gen_server:call(Pid, {get_childspec, cowboy_websocket}, 1000),
+ ok.
+
+%% supervisor:restart_child/2.
+
+supervisor_restart_child_not_found_h1(Config) ->
+ doc("h1: The function supervisor:restart_child/2 must return {error, not_found}."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [{active, false}]),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% When no children exist.
+ {error, not_found} = supervisor:restart_child(Pid, cowboy_http),
+ %% When a child exists.
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ {error, not_found} = supervisor:restart_child(Pid, cowboy_http),
+ ok.
+
+supervisor_restart_child_not_found_h2(Config) ->
+ doc("h2: The function supervisor:restart_child/2 must return {error, not_found}."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Do the handshake.
+ ok = ssl:send(Socket, ["PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", cow_http2:settings(#{})]),
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ ok = ssl:send(Socket, cow_http2:settings_ack()),
+ {ok, << 0:24, 4:8, 1:8, 0:32 >>} = ssl:recv(Socket, 9, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ %% When no children exist.
+ {error, not_found} = supervisor:restart_child(Pid, cowboy_http2),
+ %% When a child exists.
+ {HeadersBlock, _} = cow_hpack:encode([
+ {<<":method">>, <<"GET">>},
+ {<<":scheme">>, <<"https">>},
+ {<<":authority">>, <<"localhost">>}, %% @todo Correct port number.
+ {<<":path">>, <<"/loop">>}
+ ]),
+ ok = ssl:send(Socket, cow_http2:headers(1, fin, HeadersBlock)),
+ timer:sleep(100),
+ {error, not_found} = supervisor:restart_child(Pid, cowboy_http2),
+ ok.
+
+supervisor_restart_child_not_found_ws(Config) ->
+ doc("ws: The function supervisor:restart_child/2 must return {error, not_found}."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% We use gen_server:call directly because the supervisor:restart_child
+ %% function has a timeout of infinity.
+ %% @todo This can be changed to supervisor:restart_child/2 once it is fixed.
+ {error, not_found} = gen_server:call(Pid, {restart_child, cowboy_websocket}, 1000),
+ ok.
+
+%% supervisor:start_child/2 must return {error, start_child_disabled}
+
+supervisor_start_child_not_found_h1(Config) ->
+ doc("h1: The function supervisor:start_child/2 must return {error, start_child_disabled}."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [{active, false}]),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ {error, start_child_disabled} = supervisor:start_child(Pid, #{
+ id => error,
+ start => {error, error, []}
+ }),
+ ok.
+
+supervisor_start_child_not_found_h2(Config) ->
+ doc("h2: The function supervisor:start_child/2 must return {error, start_child_disabled}."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Do the handshake.
+ ok = ssl:send(Socket, ["PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", cow_http2:settings(#{})]),
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ ok = ssl:send(Socket, cow_http2:settings_ack()),
+ {ok, << 0:24, 4:8, 1:8, 0:32 >>} = ssl:recv(Socket, 9, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ {error, start_child_disabled} = supervisor:start_child(Pid, #{
+ id => error,
+ start => {error, error, []}
+ }),
+ ok.
+
+supervisor_start_child_not_found_ws(Config) ->
+ doc("ws: The function supervisor:start_child/2 must return {error, start_child_disabled}."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% We use gen_server:call directly because the supervisor:start_child
+ %% function has a timeout of infinity.
+ %% @todo This can be changed to supervisor:start_child/2 once it is fixed.
+ {error, start_child_disabled} = gen_server:call(Pid, {start_child, #{
+ id => error,
+ start => {error, error, []}
+ }}, 1000),
+ ok.
+
+%% supervisor:terminate_child/2.
+
+supervisor_terminate_child_not_found_h1(Config) ->
+ doc("h1: The function supervisor:terminate_child/2 must return {error, not_found}."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [{active, false}]),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% When no children exist.
+ {error, not_found} = supervisor:terminate_child(Pid, cowboy_http),
+ %% When a child exists.
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ {error, not_found} = supervisor:terminate_child(Pid, cowboy_http),
+ ok.
+
+supervisor_terminate_child_not_found_h2(Config) ->
+ doc("h2: The function supervisor:terminate_child/2 must return {error, not_found}."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Do the handshake.
+ ok = ssl:send(Socket, ["PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", cow_http2:settings(#{})]),
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ ok = ssl:send(Socket, cow_http2:settings_ack()),
+ {ok, << 0:24, 4:8, 1:8, 0:32 >>} = ssl:recv(Socket, 9, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ %% When no children exist.
+ {error, not_found} = supervisor:terminate_child(Pid, cowboy_http2),
+ %% When a child exists.
+ {HeadersBlock, _} = cow_hpack:encode([
+ {<<":method">>, <<"GET">>},
+ {<<":scheme">>, <<"https">>},
+ {<<":authority">>, <<"localhost">>}, %% @todo Correct port number.
+ {<<":path">>, <<"/loop">>}
+ ]),
+ ok = ssl:send(Socket, cow_http2:headers(1, fin, HeadersBlock)),
+ timer:sleep(100),
+ {error, not_found} = supervisor:terminate_child(Pid, cowboy_http2),
+ ok.
+
+supervisor_terminate_child_not_found_ws(Config) ->
+ doc("ws: The function supervisor:terminate_child/2 must return {error, not_found}."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% We use gen_server:call directly because the supervisor:terminate_child
+ %% function has a timeout of infinity.
+ %% @todo This can be changed to supervisor:terminate_child/2 once it is fixed.
+ {error, not_found} = gen_server:call(Pid, {terminate_child, cowboy_websocket}, 1000),
+ ok.
+
+%% supervisor:which_children/1.
+%%
+%% @todo The list of modules returned is probably wrong. This will
+%% need to be corrected when get_modules gets implemented.
+
+supervisor_which_children_h1(Config) ->
+ doc("h1: The function supervisor:which_children/1 must work."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [{active, false}]),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% No request was sent so there's no children.
+ [] = supervisor:which_children(Pid),
+ %% Send a request, observe that a children exists.
+ ok = gen_tcp:send(Socket,
+ "GET /loop HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "\r\n"),
+ timer:sleep(100),
+ [{cowboy_http, Child, worker, [cowboy_http]}] = supervisor:which_children(Pid),
+ true = is_pid(Child),
+ ok.
+
+supervisor_which_children_h2(Config) ->
+ doc("h2: The function supervisor:which_children/1 must work."),
+ {ok, Socket} = ssl:connect("localhost", config(tls_port, Config),
+ [{active, false}, binary, {alpn_advertised_protocols, [<<"h2">>]}]),
+ %% Do the handshake.
+ ok = ssl:send(Socket, ["PRI * HTTP/2.0\r\n\r\nSM\r\n\r\n", cow_http2:settings(#{})]),
+ {ok, <<_,_,_,4,_/bits>>} = ssl:recv(Socket, 0, 1000),
+ ok = ssl:send(Socket, cow_http2:settings_ack()),
+ {ok, << 0:24, 4:8, 1:8, 0:32 >>} = ssl:recv(Socket, 9, 1000),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tls(Socket),
+ %% No request was sent so there's no children.
+ [] = supervisor:which_children(Pid),
+ %% Send a request, observe that a children exists.
+ {HeadersBlock, _} = cow_hpack:encode([
+ {<<":method">>, <<"GET">>},
+ {<<":scheme">>, <<"https">>},
+ {<<":authority">>, <<"localhost">>}, %% @todo Correct port number.
+ {<<":path">>, <<"/loop">>}
+ ]),
+ ok = ssl:send(Socket, cow_http2:headers(1, fin, HeadersBlock)),
+ timer:sleep(100),
+ [{cowboy_http2, Child, worker, [cowboy_http2]}] = supervisor:which_children(Pid),
+ true = is_pid(Child),
+ ok.
+
+supervisor_which_children_ws(Config) ->
+ doc("ws: The function supervisor:which_children/1 must work. "
+ "Websocket connections never have children."),
+ {ok, Socket} = gen_tcp:connect("localhost", config(clear_port, Config),
+ [binary, {active, false}]),
+ ok = gen_tcp:send(Socket,
+ "GET /ws HTTP/1.1\r\n"
+ "Host: localhost\r\n"
+ "Connection: Upgrade\r\n"
+ "Origin: http://localhost\r\n"
+ "Sec-WebSocket-Version: 13\r\n"
+ "Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==\r\n"
+ "Upgrade: websocket\r\n"
+ "\r\n"),
+ {ok, Handshake} = gen_tcp:recv(Socket, 0, 5000),
+ {ok, {http_response, {1, 1}, 101, _}, _} = erlang:decode_packet(http, Handshake, []),
+ timer:sleep(100),
+ Pid = do_get_remote_pid_tcp(Socket),
+ %% We use gen_server:call directly because the supervisor:which_children
+ %% function has a timeout of infinity.
+ %% @todo This can be changed to supervisor:which_children/1 once it is fixed.
+ [] = gen_server:call(Pid, which_children, 1000),
+ ok.