10 files changed, 405 insertions, 43 deletions

diff --git a/ebin/cowboy.app b/ebin/cowboy.app
index ce3ccc4..e4c1cd9 100644
--- a/ebin/cowboy.app
+++ b/ebin/cowboy.app
@@ -1,7 +1,7 @@
 {application, 'cowboy', [
 	{description, "Small, fast, modern HTTP server."},
 	{vsn, "2.0.0-pre.4"},
-	{modules, ['cowboy','cowboy_app','cowboy_bstr','cowboy_clear','cowboy_clock','cowboy_constraints','cowboy_handler','cowboy_http','cowboy_http2','cowboy_loop','cowboy_middleware','cowboy_req','cowboy_rest','cowboy_router','cowboy_static','cowboy_stream','cowboy_stream_h','cowboy_sub_protocol','cowboy_sup','cowboy_tls','cowboy_websocket']},
+	{modules, ['cowboy','cowboy_app','cowboy_bstr','cowboy_clear','cowboy_clock','cowboy_compress_h','cowboy_constraints','cowboy_handler','cowboy_http','cowboy_http2','cowboy_loop','cowboy_middleware','cowboy_req','cowboy_rest','cowboy_router','cowboy_static','cowboy_stream','cowboy_stream_h','cowboy_sub_protocol','cowboy_sup','cowboy_tls','cowboy_websocket']},
 	{registered, [cowboy_sup,cowboy_clock]},
 	{applications, [kernel,stdlib,crypto,cowlib,ranch]},
 	{mod, {cowboy_app, []}},
diff --git a/src/cowboy_compress_h.erl b/src/cowboy_compress_h.erl
new file mode 100644
index 0000000..229e75f
--- /dev/null
+++ b/src/cowboy_compress_h.erl
@@ -0,0 +1,167 @@
+%% Copyright (c) 2017, 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(cowboy_compress_h).
+-behavior(cowboy_stream).
+
+-export([init/3]).
+-export([data/4]).
+-export([info/3]).
+-export([terminate/3]).
+
+-record(state, {
+	next :: any(),
+	compress = undefined :: undefined | gzip,
+	deflate = undefined :: undefined | zlib:zstream()
+}).
+
+-spec init(cowboy_stream:streamid(), cowboy_req:req(), cowboy:opts())
+	-> {cowboy_stream:commands(), #state{}}.
+init(StreamID, Req, Opts) ->
+	State0 = check_req(Req),
+	{Commands0, Next} = cowboy_stream:init(StreamID, Req, Opts),
+	fold(Commands0, State0#state{next=Next}).
+
+-spec data(cowboy_stream:streamid(), cowboy_stream:fin(), cowboy_req:resp_body(), State)
+	-> {cowboy_stream:commands(), State} when State::#state{}.
+data(StreamID, IsFin, Data, State0=#state{next=Next0}) ->
+	{Commands0, Next} = cowboy_stream:data(StreamID, IsFin, Data, Next0),
+	fold(Commands0, State0#state{next=Next}).
+
+-spec info(cowboy_stream:streamid(), any(), State)
+	-> {cowboy_stream:commands(), State} when State::#state{}.
+info(StreamID, Info, State0=#state{next=Next0}) ->
+	{Commands0, Next} = cowboy_stream:info(StreamID, Info, Next0),
+	fold(Commands0, State0#state{next=Next}).
+
+-spec terminate(cowboy_stream:streamid(), cowboy_stream:reason(), #state{}) -> any().
+terminate(StreamID, Reason, #state{next=Next, deflate=Z}) ->
+	%% Clean the zlib:stream() in case something went wrong.
+	%% In the normal scenario the stream is already closed.
+	case Z of
+		undefined -> ok;
+		_ -> zlib:close(Z)
+	end,
+	cowboy_stream:terminate(StreamID, Reason, Next).
+
+%% Internal.
+
+%% Check if the client supports decoding of gzip responses.
+check_req(Req) ->
+	case cowboy_req:parse_header(<<"accept-encoding">>, Req) of
+		%% Client doesn't support any compression algorithm.
+		undefined ->
+			#state{compress=undefined};
+		Encodings ->
+			%% We only support gzip so look for it specifically.
+			%% @todo A recipient SHOULD consider "x-gzip" to be
+			%% equivalent to "gzip". (RFC7230 4.2.3)
+			case [E || E={<<"gzip">>, Q} <- Encodings, Q =/= 0] of
+				[] ->
+					#state{compress=undefined};
+				_ ->
+					#state{compress=gzip}
+			end
+	end.
+
+%% Do not compress responses that contain the content-encoding header.
+check_resp_headers(#{<<"content-encoding">> := _}, State) ->
+	State#state{compress=undefined};
+check_resp_headers(_, State) ->
+	State.
+
+fold(Commands, State=#state{compress=undefined}) ->
+	{Commands, State};
+fold(Commands, State) ->
+	fold(Commands, State, []).
+
+fold([], State, Acc) ->
+	{lists:reverse(Acc), State};
+%% We do not compress sendfile bodies.
+fold([Response={response, _, _, {sendfile, _, _, _}}|Tail], State, Acc) ->
+	fold(Tail, State, [Response|Acc]);
+%% We compress full responses directly, unless they are lower than
+%% 300 bytes or we find we are not able to by looking at the headers.
+%% @todo It might be good to allow this size to be configured?
+fold([Response0={response, _, Headers, Body}|Tail], State0, Acc) ->
+	case check_resp_headers(Headers, State0) of
+		State=#state{compress=undefined} ->
+			fold(Tail, State, [Response0|Acc]);
+		State1 ->
+			BodyLength = iolist_size(Body),
+			if
+				BodyLength =< 300 ->
+					fold(Tail, State1, [Response0|Acc]);
+				true ->
+					{Response, State} = gzip_response(Response0, State1),
+					fold(Tail, State, [Response|Acc])
+			end
+	end;
+%% Check headers and initiate compression...
+fold([Response0={headers, _, Headers}|Tail], State0, Acc) ->
+	case check_resp_headers(Headers, State0) of
+		State=#state{compress=undefined} ->
+			fold(Tail, State, [Response0|Acc]);
+		State1 ->
+			{Response, State} = gzip_headers(Response0, State1),
+			fold(Tail, State, [Response|Acc])
+	end;
+%% then compress each data commands individually.
+fold([Data0={data, _, _}|Tail], State0=#state{compress=gzip}, Acc) ->
+	{Data, State} = gzip_data(Data0, State0),
+	fold(Tail, State, [Data|Acc]);
+%% Otherwise, we either have an unrelated command, or a data command
+%% with compression disabled.
+fold([Command|Tail], State, Acc) ->
+	fold(Tail, State, [Command|Acc]).
+
+gzip_response({response, Status, Headers, Body}, State) ->
+	%% We can't call zlib:gzip/1 because it does an
+	%% iolist_to_binary(GzBody) at the end to return
+	%% a binary(). Therefore the code here is largely
+	%% a duplicate of the code of that function.
+	Z = zlib:open(),
+	GzBody = try
+		%% 31 = 16+?MAX_WBITS from zlib.erl
+		%% @todo It might be good to allow them to be configured?
+		zlib:deflateInit(Z, default, deflated, 31, 8, default),
+		Gz = zlib:deflate(Z, Body, finish),
+		zlib:deflateEnd(Z),
+		Gz
+	after
+		zlib:close(Z)
+	end,
+	{{response, Status, Headers#{
+		<<"content-length">> => integer_to_binary(iolist_size(GzBody)),
+		<<"content-encoding">> => <<"gzip">>
+	}, GzBody}, State}.
+
+gzip_headers({headers, Status, Headers0}, State) ->
+	Z = zlib:open(),
+	%% We use the same arguments as when compressing the body fully.
+	%% @todo It might be good to allow them to be configured?
+	zlib:deflateInit(Z, default, deflated, 31, 8, default),
+	Headers = maps:remove(<<"content-length">>, Headers0),
+	{{headers, Status, Headers#{
+		<<"content-encoding">> => <<"gzip">>
+	}}, State#state{deflate=Z}}.
+
+gzip_data({data, nofin, Data0}, State=#state{deflate=Z}) ->
+	Data = zlib:deflate(Z, Data0),
+	{{data, nofin, Data}, State};
+gzip_data({data, fin, Data0}, State=#state{deflate=Z}) ->
+	Data = zlib:deflate(Z, Data0, finish),
+	zlib:deflateEnd(Z),
+	zlib:close(Z),
+	{{data, fin, Data}, State#state{deflate=undefined}}.
diff --git a/test/compress_SUITE.erl b/test/compress_SUITE.erl
new file mode 100644
index 0000000..2bd002d
--- /dev/null
+++ b/test/compress_SUITE.erl
@@ -0,0 +1,129 @@
+%% Copyright (c) 2017, 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(compress_SUITE).
+-compile(export_all).
+
+-import(ct_helper, [config/2]).
+-import(ct_helper, [doc/1]).
+-import(cowboy_test, [gun_open/1]).
+
+%% ct.
+
+all() ->
+	[
+		{group, http_compress},
+		{group, https_compress},
+		{group, h2_compress},
+		{group, h2c_compress}
+	].
+
+groups() ->
+	cowboy_test:common_groups(ct_helper:all(?MODULE)).
+
+init_per_group(Name, Config) ->
+	cowboy_test:init_common_groups(Name, Config, ?MODULE).
+
+end_per_group(Name, _) ->
+	cowboy:stop_listener(Name).
+
+%% Routes.
+
+init_dispatch(Config) ->
+	cowboy_router:compile([{"[...]", [
+		{"/reply/:what", compress_h, reply},
+		{"/stream_reply/:what", compress_h, stream_reply}
+	]}]).
+
+%% Internal.
+
+do_get(Path, ReqHeaders, Config) ->
+	ConnPid = gun_open(Config),
+	Ref = gun:get(ConnPid, Path, ReqHeaders),
+	{response, IsFin, Status, RespHeaders} = gun:await(ConnPid, Ref),
+	{ok, Body} = case IsFin of
+		nofin -> gun:await_body(ConnPid, Ref);
+		fin -> {ok, <<>>}
+	end,
+	gun:close(ConnPid),
+	{Status, RespHeaders, Body}.
+
+%% Tests.
+
+gzip_accept_encoding_missing(Config) ->
+	doc("Don't send accept-encoding; get an uncompressed response."),
+	{200, Headers, _} = do_get("/reply/large",
+		[], Config),
+	false = lists:keyfind(<<"content-encoding">>, 1, Headers),
+	{_, <<"100000">>} = lists:keyfind(<<"content-length">>, 1, Headers),
+	ok.
+
+gzip_accept_encoding_no_gzip(Config) ->
+	doc("Send accept-encoding: compress (unsupported by Cowboy); get an uncompressed response."),
+	{200, Headers, _} = do_get("/reply/large",
+		[{<<"accept-encoding">>, <<"compress">>}], Config),
+	false = lists:keyfind(<<"content-encoding">>, 1, Headers),
+	{_, <<"100000">>} = lists:keyfind(<<"content-length">>, 1, Headers),
+	ok.
+
+gzip_reply_content_encoding(Config) ->
+	doc("Reply with content-encoding header; get an uncompressed response."),
+	{200, Headers, _} = do_get("/reply/content-encoding",
+		[{<<"accept-encoding">>, <<"gzip">>}], Config),
+	%% We set the content-encoding to compress; without actually compressing.
+	{_, <<"compress">>} = lists:keyfind(<<"content-encoding">>, 1, Headers),
+	{_, <<"100000">>} = lists:keyfind(<<"content-length">>, 1, Headers),
+	ok.
+
+gzip_reply_large_body(Config) ->
+	doc("Reply a large body; get a gzipped response."),
+	{200, Headers, GzBody} = do_get("/reply/large",
+		[{<<"accept-encoding">>, <<"gzip">>}], Config),
+	{_, <<"gzip">>} = lists:keyfind(<<"content-encoding">>, 1, Headers),
+	{_, Length} = lists:keyfind(<<"content-length">>, 1, Headers),
+	ct:log("Original length: 100000; compressed: ~s.", [Length]),
+	_ = zlib:gunzip(GzBody),
+	ok.
+
+gzip_reply_sendfile(Config) ->
+	doc("Reply using sendfile; get an uncompressed response."),
+	{200, Headers, Body} = do_get("/reply/sendfile",
+		[{<<"accept-encoding">>, <<"gzip">>}], Config),
+	false = lists:keyfind(<<"content-encoding">>, 1, Headers),
+	ct:log("Body received:~n~p~n", [Body]),
+	ok.
+
+gzip_reply_small_body(Config) ->
+	doc("Reply a small body; get an uncompressed response."),
+	{200, Headers, _} = do_get("/reply/small",
+		[{<<"accept-encoding">>, <<"gzip">>}], Config),
+	false = lists:keyfind(<<"content-encoding">>, 1, Headers),
+	{_, <<"100">>} = lists:keyfind(<<"content-length">>, 1, Headers),
+	ok.
+
+gzip_stream_reply(Config) ->
+	doc("Stream reply; get a gzipped response."),
+	{200, Headers, GzBody} = do_get("/stream_reply/large",
+		[{<<"accept-encoding">>, <<"gzip">>}], Config),
+	{_, <<"gzip">>} = lists:keyfind(<<"content-encoding">>, 1, Headers),
+	_ = zlib:gunzip(GzBody),
+	ok.
+
+gzip_stream_reply_content_encoding(Config) ->
+	doc("Stream reply with content-encoding header; get an uncompressed response."),
+	{200, Headers, Body} = do_get("/stream_reply/content-encoding",
+		[{<<"accept-encoding">>, <<"gzip">>}], Config),
+	{_, <<"compress">>} = lists:keyfind(<<"content-encoding">>, 1, Headers),
+	100000 = iolist_size(Body),
+	ok.
diff --git a/test/cowboy_test.erl b/test/cowboy_test.erl
index bb74ad0..a219878 100644
--- a/test/cowboy_test.erl
+++ b/test/cowboy_test.erl
@@ -43,10 +43,11 @@ common_all() ->
 		{group, http},
 		{group, https},
 		{group, h2},
-		{group, h2c}%,
-%% @todo
-%		{group, http_compress},
-%		{group, https_compress}
+		{group, h2c},
+		{group, http_compress},
+		{group, https_compress},
+		{group, h2_compress},
+		{group, h2c_compress}
 	].
 
 common_groups(Tests) ->
@@ -54,31 +55,51 @@ common_groups(Tests) ->
 		{http, [parallel], Tests},
 		{https, [parallel], Tests},
 		{h2, [parallel], Tests},
-		{h2c, [parallel], Tests}%,
-%% @todo
-%		{http_compress, [parallel], Tests},
-%		{https_compress, [parallel], Tests}
+		{h2c, [parallel], Tests},
+		{http_compress, [parallel], Tests},
+		{https_compress, [parallel], Tests},
+		{h2_compress, [parallel], Tests},
+		{h2c_compress, [parallel], Tests}
 	].
 
 init_common_groups(Name = http, Config, Mod) ->
-	init_http(Name, #{env => #{dispatch => Mod:init_dispatch(Config)}}, Config);
+	init_http(Name, #{
+		env => #{dispatch => Mod:init_dispatch(Config)}
+	}, Config);
 init_common_groups(Name = https, Config, Mod) ->
-	init_https(Name, #{env => #{dispatch => Mod:init_dispatch(Config)}}, Config);
+	init_https(Name, #{
+		env => #{dispatch => Mod:init_dispatch(Config)}
+	}, Config);
 init_common_groups(Name = h2, Config, Mod) ->
-	init_http2(Name, #{env => #{dispatch => Mod:init_dispatch(Config)}}, Config);
+	init_http2(Name, #{
+		env => #{dispatch => Mod:init_dispatch(Config)}
+	}, Config);
 init_common_groups(Name = h2c, Config, Mod) ->
-	Config1 = init_http(Name, #{env => #{dispatch => Mod:init_dispatch(Config)}}, Config),
+	Config1 = init_http(Name, #{
+		env => #{dispatch => Mod:init_dispatch(Config)}
+	}, Config),
 	lists:keyreplace(protocol, 1, Config1, {protocol, http2});
 init_common_groups(Name = http_compress, Config, Mod) ->
 	init_http(Name, #{
 		env => #{dispatch => Mod:init_dispatch(Config)},
-		compress => true
+		stream_handlers => [cowboy_compress_h, cowboy_stream_h]
 	}, Config);
 init_common_groups(Name = https_compress, Config, Mod) ->
 	init_https(Name, #{
 		env => #{dispatch => Mod:init_dispatch(Config)},
-		compress => true
-	}, Config).
+		stream_handlers => [cowboy_compress_h, cowboy_stream_h]
+	}, Config);
+init_common_groups(Name = h2_compress, Config, Mod) ->
+	init_http2(Name, #{
+		env => #{dispatch => Mod:init_dispatch(Config)},
+		stream_handlers => [cowboy_compress_h, cowboy_stream_h]
+	}, Config);
+init_common_groups(Name = h2c_compress, Config, Mod) ->
+	Config1 = init_http(Name, #{
+		env => #{dispatch => Mod:init_dispatch(Config)},
+		stream_handlers => [cowboy_compress_h, cowboy_stream_h]
+	}, Config),
+	lists:keyreplace(protocol, 1, Config1, {protocol, http2}).
 
 %% Support functions for testing using Gun.
 
diff --git a/test/handlers/compress_h.erl b/test/handlers/compress_h.erl
new file mode 100644
index 0000000..5787b66
--- /dev/null
+++ b/test/handlers/compress_h.erl
@@ -0,0 +1,37 @@
+%% This module sends a response body of varying sizes to test
+%% the cowboy_compress_h stream handler.
+
+-module(compress_h).
+
+-export([init/2]).
+
+init(Req0, State=reply) ->
+	Req = case cowboy_req:binding(what, Req0) of
+		<<"small">> ->
+			cowboy_req:reply(200, #{}, lists:duplicate(100, $a), Req0);
+		<<"large">> ->
+			cowboy_req:reply(200, #{}, lists:duplicate(100000, $a), Req0);
+		<<"content-encoding">> ->
+			cowboy_req:reply(200, #{<<"content-encoding">> => <<"compress">>},
+				lists:duplicate(100000, $a), Req0);
+		<<"sendfile">> ->
+			AppFile = code:where_is_file("cowboy.app"),
+			Size = filelib:file_size(AppFile),
+			cowboy_req:reply(200, #{}, {sendfile, 0, Size, AppFile}, Req0)
+	end,
+	{ok, Req, State};
+init(Req0, State=stream_reply) ->
+	Req = case cowboy_req:binding(what, Req0) of
+		<<"large">> ->
+			stream_reply(#{}, Req0);
+		<<"content-encoding">> ->
+			stream_reply(#{<<"content-encoding">> => <<"compress">>}, Req0)
+	end,
+	{ok, Req, State}.
+
+stream_reply(Headers, Req0) ->
+	Data = lists:duplicate(10000, $a),
+	Req = cowboy_req:stream_reply(200, Headers, Req0),
+	_ = [cowboy_req:stream_body(Data, nofin, Req) || _ <- lists:seq(1,9)],
+	cowboy_req:stream_body(Data, fin, Req),
+	Req.
diff --git a/test/handlers/echo_h.erl b/test/handlers/echo_h.erl
index fb7d8a8..5042ca8 100644
--- a/test/handlers/echo_h.erl
+++ b/test/handlers/echo_h.erl
@@ -79,5 +79,5 @@ read_body(Req0, Acc) ->
 
 value_to_iodata(V) when is_integer(V) -> integer_to_binary(V);
 value_to_iodata(V) when is_atom(V) -> atom_to_binary(V, latin1);
-value_to_iodata(V) when is_list(V); is_tuple(V); is_map(V) -> io_lib:format("~p", [V]);
+value_to_iodata(V) when is_list(V); is_tuple(V); is_map(V) -> io_lib:format("~999999p", [V]);
 value_to_iodata(V) -> V.
diff --git a/test/handlers/resp_h.erl b/test/handlers/resp_h.erl
index 658c5f8..5e6696e 100644
--- a/test/handlers/resp_h.erl
+++ b/test/handlers/resp_h.erl
@@ -28,7 +28,7 @@ do(<<"set_resp_header">>, Req0, Opts) ->
 do(<<"set_resp_headers">>, Req0, Opts) ->
 	Req = cowboy_req:set_resp_headers(#{
 		<<"content-type">> => <<"text/plain">>,
-		<<"content-encoding">> => <<"gzip">>
+		<<"content-encoding">> => <<"compress">>
 	}, Req0),
 	{ok, cowboy_req:reply(200, #{}, "OK", Req), Opts};
 do(<<"resp_header_defined">>, Req0, Opts) ->
@@ -44,7 +44,7 @@ do(<<"resp_headers">>, Req0, Opts) ->
 	Req1 = cowboy_req:set_resp_header(<<"server">>, <<"nginx">>, Req0),
 	Req = cowboy_req:set_resp_headers(#{
 		<<"content-type">> => <<"text/plain">>,
-		<<"content-encoding">> => <<"gzip">>
+		<<"content-encoding">> => <<"compress">>
 	}, Req1),
 	Headers = cowboy_req:resp_headers(Req),
 	true = maps:is_key(<<"server">>, Headers),
diff --git a/test/loop_handler_SUITE.erl b/test/loop_handler_SUITE.erl
index 7e26d60..5feb032 100644
--- a/test/loop_handler_SUITE.erl
+++ b/test/loop_handler_SUITE.erl
@@ -47,41 +47,45 @@ init_dispatch(_) ->
 long_polling(Config) ->
 	doc("Simple long-polling."),
 	ConnPid = gun_open(Config),
-	Ref = gun:get(ConnPid, "/long_polling"),
+	Ref = gun:get(ConnPid, "/long_polling", [{<<"accept-encoding">>, <<"gzip">>}]),
 	{response, fin, 102, _} = gun:await(ConnPid, Ref),
 	ok.
 
 long_polling_body(Config) ->
 	doc("Long-polling with a body that falls within the configurable limits."),
 	ConnPid = gun_open(Config),
-	Ref = gun:post(ConnPid, "/long_polling", [], << 0:5000/unit:8 >>),
+	Ref = gun:post(ConnPid, "/long_polling", [{<<"accept-encoding">>, <<"gzip">>}],
+		<< 0:5000/unit:8 >>),
 	{response, fin, 102, _} = gun:await(ConnPid, Ref),
 	ok.
 
 long_polling_body_too_large(Config) ->
 	doc("Long-polling with a body that exceeds the configurable limits."),
 	ConnPid = gun_open(Config),
-	Ref = gun:post(ConnPid, "/long_polling", [], << 0:100000/unit:8 >>),
+	Ref = gun:post(ConnPid, "/long_polling", [{<<"accept-encoding">>, <<"gzip">>}],
+		<< 0:100000/unit:8 >>),
 	{response, fin, 500, _} = gun:await(ConnPid, Ref),
 	ok.
 
 long_polling_pipeline(Config) ->
 	doc("Pipeline of long-polling calls."),
 	ConnPid = gun_open(Config),
-	Refs = [gun:get(ConnPid, "/long_polling") || _ <- lists:seq(1, 2)],
+	Refs = [gun:get(ConnPid, "/long_polling", [{<<"accept-encoding">>, <<"gzip">>}])
+		|| _ <- lists:seq(1, 2)],
 	_ = [{response, fin, 102, _} = gun:await(ConnPid, Ref) || Ref <- Refs],
 	ok.
 
 loop_body(Config) ->
 	doc("Check that a loop handler can read the request body in info/3."),
 	ConnPid = gun_open(Config),
-	Ref = gun:post(ConnPid, "/loop_body", [], << 0:100000/unit:8 >>),
+	Ref = gun:post(ConnPid, "/loop_body", [{<<"accept-encoding">>, <<"gzip">>}],
+		<< 0:100000/unit:8 >>),
 	{response, fin, 200, _} = gun:await(ConnPid, Ref),
 	ok.
 
 loop_timeout(Config) ->
 	doc("Ensure that the loop handler timeout results in a 204 response."),
 	ConnPid = gun_open(Config),
-	Ref = gun:get(ConnPid, "/loop_timeout"),
+	Ref = gun:get(ConnPid, "/loop_timeout", [{<<"accept-encoding">>, <<"gzip">>}]),
 	{response, fin, 204, _} = gun:await(ConnPid, Ref),
 	ok.
diff --git a/test/req_SUITE.erl b/test/req_SUITE.erl
index 769daf3..8f10ca3 100644
--- a/test/req_SUITE.erl
+++ b/test/req_SUITE.erl
@@ -25,14 +25,7 @@ all() ->
 	cowboy_test:common_all().
 
 groups() ->
-	AllTests = ct_helper:all(?MODULE),
-	[
-		{http, [parallel], AllTests},
-		{https, [parallel], AllTests},
-		{h2, [parallel], AllTests},
-		{h2c, [parallel], AllTests}
-		%% @todo With compression enabled.
-	].
+	cowboy_test:common_groups(ct_helper:all(?MODULE)).
 
 init_per_suite(Config) ->
 	ct_helper:create_static_dir(config(priv_dir, Config) ++ "/static"),
@@ -74,30 +67,31 @@ do_body(Method, Path, Config) ->
 do_body(Method, Path, Headers, Config) ->
 	do_body(Method, Path, Headers, <<>>, Config).
 
-do_body(Method, Path, Headers, Body, Config) ->
+do_body(Method, Path, Headers0, Body, Config) ->
 	ConnPid = gun_open(Config),
+	Headers = [{<<"accept-encoding">>, <<"gzip">>}|Headers0],
 	Ref = case Body of
 		<<>> -> gun:request(ConnPid, Method, Path, Headers);
 		_ -> gun:request(ConnPid, Method, Path, Headers, Body)
 	end,
-	{response, IsFin, 200, _} = gun:await(ConnPid, Ref),
+	{response, IsFin, 200, RespHeaders} = gun:await(ConnPid, Ref),
 	{ok, RespBody} = case IsFin of
 		nofin -> gun:await_body(ConnPid, Ref);
 		fin -> {ok, <<>>}
 	end,
 	gun:close(ConnPid),
-	RespBody.
+	do_decode(RespHeaders, RespBody).
 
 do_get(Path, Config) ->
 	ConnPid = gun_open(Config),
-	Ref = gun:get(ConnPid, Path, []),
-	{response, IsFin, Status, Headers} = gun:await(ConnPid, Ref),
+	Ref = gun:get(ConnPid, Path, [{<<"accept-encoding">>, <<"gzip">>}]),
+	{response, IsFin, Status, RespHeaders} = gun:await(ConnPid, Ref),
 	{ok, RespBody} = case IsFin of
 		nofin -> gun:await_body(ConnPid, Ref);
 		fin -> {ok, <<>>}
 	end,
 	gun:close(ConnPid),
-	{Status, Headers, RespBody}.
+	{Status, RespHeaders, do_decode(RespHeaders, RespBody)}.
 
 do_get_body(Path, Config) ->
 	do_get_body(Path, [], Config).
@@ -105,6 +99,12 @@ do_get_body(Path, Config) ->
 do_get_body(Path, Headers, Config) ->
 	do_body("GET", Path, Headers, Config).
 
+do_decode(Headers, Body) ->
+	case lists:keyfind(<<"content-encoding">>, 1, Headers) of
+		{_, <<"gzip">>} -> zlib:gunzip(Body);
+		_ -> Body
+	end.
+
 %% Tests: Request.
 
 binding(Config) ->
@@ -129,7 +129,8 @@ header(Config) ->
 
 headers(Config) ->
 	doc("Request headers."),
-	<< "#{<<\"header\">> => <<\"value\">>", _/bits >>
+	%% We always send accept-encoding with this test suite's requests.
+	<<"#{<<\"accept-encoding\">> => <<\"gzip\">>,<<\"header\">> => <<\"value\">>", _/bits>>
 		= do_get_body("/headers", [{<<"header">>, "value"}], Config),
 	ok.
 
diff --git a/test/static_handler_SUITE.erl b/test/static_handler_SUITE.erl
index 15fd473..78926ee 100644
--- a/test/static_handler_SUITE.erl
+++ b/test/static_handler_SUITE.erl
@@ -39,8 +39,11 @@ groups() ->
 		{http, [parallel], GroupTests},
 		{https, [parallel], GroupTests},
 		{h2, [parallel], GroupTests},
-		{h2c, [parallel], GroupTests}
-		%% @todo With compression enabled.
+		{h2c, [parallel], GroupTests},
+		{http_compress, [parallel], GroupTests},
+		{https_compress, [parallel], GroupTests},
+		{h2_compress, [parallel], GroupTests},
+		{h2c_compress, [parallel], GroupTests}
 	].
 
 init_per_suite(Config) ->
@@ -171,7 +174,7 @@ do_get(Path, Config) ->
 
 do_get(Path, ReqHeaders, Config) ->
 	ConnPid = gun_open(Config),
-	Ref = gun:get(ConnPid, Path, ReqHeaders),
+	Ref = gun:get(ConnPid, Path, [{<<"accept-encoding">>, <<"gzip">>}|ReqHeaders]),
 	{response, IsFin, Status, RespHeaders} = gun:await(ConnPid, Ref),
 	{ok, Body} = case IsFin of
 		nofin -> gun:await_body(ConnPid, Ref);