test/couchdb_attachments_tests.erl - couchdb-couch - Git at Google

 % Licensed under the Apache License, Version 2.0 (the "License"); you may not
 % use this file except in compliance with the License. You may obtain a copy of
 % the License at
 %
 %   http://www.apache.org/licenses/LICENSE-2.0
 %
 % Unless required by applicable law or agreed to in writing, software
 % distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
 % WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
 % License for the specific language governing permissions and limitations under
 % the License.

 -module(couchdb_attachments_tests).

 -include_lib("couch/include/couch_eunit.hrl").
 -include_lib("couch/include/couch_db.hrl").

 -define(COMPRESSION_LEVEL, 8).
 -define(ATT_BIN_NAME, <<"logo.png">>).
 -define(ATT_TXT_NAME, <<"file.erl">>).
 -define(FIXTURE_PNG, filename:join([?FIXTURESDIR, "logo.png"])).
 -define(FIXTURE_TXT, ?ABS_PATH(?FILE)).
 -define(TIMEOUT, 1000).
 -define(TIMEOUT_EUNIT, 10).
 -define(TIMEWAIT, 100).
 -define(i2l(I), integer_to_list(I)).


 start() ->
     Ctx = test_util:start_couch(),
     % ensure in default compression settings for attachments_compression_tests
     config:set("attachments", "compression_level",
                      ?i2l(?COMPRESSION_LEVEL), false),
     config:set("attachments", "compressible_types", "text/*", false),
     Ctx.

 setup() ->
     DbName = ?tempdb(),
     {ok, Db} = couch_db:create(DbName, []),
     ok = couch_db:close(Db),
     Addr = config:get("httpd", "bind_address", "127.0.0.1"),
     Port = mochiweb_socket_server:get(couch_httpd, port),
     Host = Addr ++ ":" ++ ?i2l(Port),
     {Host, ?b2l(DbName)}.

 setup({binary, standalone}) ->
     {Host, DbName} = setup(),
         setup_att(fun create_standalone_png_att/2, Host, DbName, ?FIXTURE_PNG);
 setup({text, standalone}) ->
     {Host, DbName} = setup(),
     setup_att(fun create_standalone_text_att/2, Host, DbName, ?FIXTURE_TXT);
 setup({binary, inline}) ->
     {Host, DbName} = setup(),
     setup_att(fun create_inline_png_att/2, Host, DbName, ?FIXTURE_PNG);
 setup({text, inline}) ->
     {Host, DbName} = setup(),
     setup_att(fun create_inline_text_att/2, Host, DbName, ?FIXTURE_TXT);
 setup(compressed) ->
     {Host, DbName} = setup(),
     setup_att(fun create_already_compressed_att/2, Host, DbName, ?FIXTURE_TXT).
 setup_att(Fun, Host, DbName, File) ->
     HttpHost = "http://" ++ Host,
     AttUrl = Fun(HttpHost, DbName),
     {ok, Data} = file:read_file(File),
     DocUrl = string:join([HttpHost, DbName, "doc"], "/"),
     Helpers = {DbName, DocUrl, AttUrl},
     {Data, Helpers}.

 teardown(_, {_, {DbName, _, _}}) ->
     teardown(DbName).

 teardown({_, DbName}) ->
     teardown(DbName);
 teardown(DbName) ->
     ok = couch_server:delete(?l2b(DbName), []),
     ok.


 attachments_test_() ->
     {
         "Attachments tests",
         {
             setup,
             fun start/0, fun test_util:stop_couch/1,
             [
                 attachments_md5_tests(),
                 attachments_compression_tests()
             ]
         }
     }.

 attachments_md5_tests() ->
     {
         "Attachments MD5 tests",
         {
             foreach,
             fun setup/0, fun teardown/1,
             [
                 fun should_upload_attachment_without_md5/1,
                 fun should_upload_attachment_by_chunks_without_md5/1,
                 fun should_upload_attachment_with_valid_md5_header/1,
                 fun should_upload_attachment_by_chunks_with_valid_md5_header/1,
                 fun should_upload_attachment_by_chunks_with_valid_md5_trailer/1,
                 fun should_reject_attachment_with_invalid_md5/1,
                 fun should_reject_chunked_attachment_with_invalid_md5/1,
                 fun should_reject_chunked_attachment_with_invalid_md5_trailer/1
             ]
         }
     }.

 attachments_compression_tests() ->
     Funs = [
          fun should_get_att_without_accept_gzip_encoding/2,
          fun should_get_att_with_accept_gzip_encoding/2,
          fun should_get_att_with_accept_deflate_encoding/2,
          fun should_return_406_response_on_unsupported_encoding/2,
          fun should_get_doc_with_att_data/2,
          fun should_get_doc_with_att_data_stub/2
     ],
     {
         "Attachments compression tests",
         [
             {
                 "Created via Attachments API",
                 created_attachments_compression_tests(standalone, Funs)
             },
             {
                 "Created inline via Document API",
                 created_attachments_compression_tests(inline, Funs)
             },
             {
                 "Created already been compressed via Attachments API",
                 {
                     foreachx,
                     fun setup/1, fun teardown/2,
                     [{compressed, Fun} || Fun <- Funs]
                 }
             },
             {
                 foreach,
                 fun setup/0, fun teardown/1,
                 [
                     fun should_not_create_compressed_att_with_deflate_encoding/1,
                     fun should_not_create_compressed_att_with_compress_encoding/1,
                     fun should_create_compressible_att_with_ctype_params/1
                 ]
             }
         ]
     }.

 created_attachments_compression_tests(Mod, Funs) ->
     [
         {
             "Compressiable attachments",
             {
                 foreachx,
                 fun setup/1, fun teardown/2,
                 [{{text, Mod}, Fun} || Fun <- Funs]
             }
         },
         {
             "Uncompressiable attachments",
             {
                 foreachx,
                 fun setup/1, fun teardown/2,
                 [{{binary, Mod}, Fun} || Fun <- Funs]
             }
         }
     ].


 should_upload_attachment_without_md5({Host, DbName}) ->
     ?_test(begin
         AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
         Body = "We all live in a yellow submarine!",
         Headers = [
             {"Content-Length", "34"},
             {"Content-Type", "text/plain"},
             {"Host", Host}
         ],
         {ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
         ?assertEqual(201, Code),
         ?assertEqual(true, get_json(Json, [<<"ok">>]))
     end).

 should_upload_attachment_by_chunks_without_md5({Host, DbName}) ->
     ?_test(begin
         AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
         AttData = <<"We all live in a yellow submarine!">>,
         <<Part1:21/binary, Part2:13/binary>> = AttData,
         Body = [chunked_body([Part1, Part2]), "\r\n"],
         Headers = [
             {"Content-Type", "text/plain"},
             {"Transfer-Encoding", "chunked"},
             {"Host", Host}
         ],
         {ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
         ?assertEqual(201, Code),
         ?assertEqual(true, get_json(Json, [<<"ok">>]))
     end).

 should_upload_attachment_with_valid_md5_header({Host, DbName}) ->
     ?_test(begin
         AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
         Body = "We all live in a yellow submarine!",
         Headers = [
             {"Content-Length", "34"},
             {"Content-Type", "text/plain"},
             {"Content-MD5", ?b2l(base64:encode(couch_crypto:hash(md5, Body)))},
             {"Host", Host}
         ],
         {ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
         ?assertEqual(201, Code),
         ?assertEqual(true, get_json(Json, [<<"ok">>]))
     end).

 should_upload_attachment_by_chunks_with_valid_md5_header({Host, DbName}) ->
     ?_test(begin
         AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
         AttData = <<"We all live in a yellow submarine!">>,
         <<Part1:21/binary, Part2:13/binary>> = AttData,
         Body = [chunked_body([Part1, Part2]), "\r\n"],
         Headers = [
             {"Content-Type", "text/plain"},
             {"Content-MD5", ?b2l(base64:encode(couch_crypto:hash(md5, AttData)))},
             {"Host", Host},
             {"Transfer-Encoding", "chunked"}
         ],
         {ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
         ?assertEqual(201, Code),
         ?assertEqual(true, get_json(Json, [<<"ok">>]))
     end).

 should_upload_attachment_by_chunks_with_valid_md5_trailer({Host, DbName}) ->
     ?_test(begin
         AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
         AttData = <<"We all live in a yellow submarine!">>,
         <<Part1:21/binary, Part2:13/binary>> = AttData,
         Body = [chunked_body([Part1, Part2]),
                 "Content-MD5: ", base64:encode(couch_crypto:hash(md5, AttData)),
                 "\r\n\r\n"],
         Headers = [
             {"Content-Type", "text/plain"},
             {"Host", Host},
             {"Trailer", "Content-MD5"},
             {"Transfer-Encoding", "chunked"}
         ],
         {ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
         ?assertEqual(201, Code),
         ?assertEqual(true, get_json(Json, [<<"ok">>]))
     end).

 should_reject_attachment_with_invalid_md5({Host, DbName}) ->
     ?_test(begin
         AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
         Body = "We all live in a yellow submarine!",
         Headers = [
             {"Content-Length", "34"},
             {"Content-Type", "text/plain"},
             {"Content-MD5", ?b2l(base64:encode(<<"foobar!">>))},
             {"Host", Host}
         ],
         {ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
         ?assertEqual(400, Code),
         ?assertEqual(<<"content_md5_mismatch">>,
                      get_json(Json, [<<"error">>]))
     end).


 should_reject_chunked_attachment_with_invalid_md5({Host, DbName}) ->
     ?_test(begin
         AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
         AttData = <<"We all live in a yellow submarine!">>,
         <<Part1:21/binary, Part2:13/binary>> = AttData,
         Body = [chunked_body([Part1, Part2]), "\r\n"],
         Headers = [
             {"Content-Type", "text/plain"},
             {"Content-MD5", ?b2l(base64:encode(<<"foobar!">>))},
             {"Host", Host},
             {"Transfer-Encoding", "chunked"}
         ],
         {ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
         ?assertEqual(400, Code),
         ?assertEqual(<<"content_md5_mismatch">>,
                      get_json(Json, [<<"error">>]))
     end).

 should_reject_chunked_attachment_with_invalid_md5_trailer({Host, DbName}) ->
     ?_test(begin
         AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
         AttData = <<"We all live in a yellow submarine!">>,
         <<Part1:21/binary, Part2:13/binary>> = AttData,
         Body = [chunked_body([Part1, Part2]),
                 "Content-MD5: ", base64:encode(<<"foobar!">>),
                 "\r\n\r\n"],
         Headers = [
             {"Content-Type", "text/plain"},
             {"Host", Host},
             {"Trailer", "Content-MD5"},
             {"Transfer-Encoding", "chunked"}
         ],
         {ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
         ?assertEqual(400, Code),
         ?assertEqual(<<"content_md5_mismatch">>, get_json(Json, [<<"error">>]))
     end).

 should_get_att_without_accept_gzip_encoding(_, {Data, {_, _, AttUrl}}) ->
     ?_test(begin
         {ok, Code, Headers, Body} = test_request:get(AttUrl),
         ?assertEqual(200, Code),
         ?assertNot(lists:member({"Content-Encoding", "gzip"}, Headers)),
         ?assertEqual(Data, iolist_to_binary(Body))
     end).

 should_get_att_with_accept_gzip_encoding(compressed, {Data, {_, _, AttUrl}}) ->
     ?_test(begin
         {ok, Code, Headers, Body} = test_request:get(
             AttUrl, [{"Accept-Encoding", "gzip"}]),
         ?assertEqual(200, Code),
         ?assert(lists:member({"Content-Encoding", "gzip"}, Headers)),
         ?assertEqual(Data, zlib:gunzip(iolist_to_binary(Body)))
     end);
 should_get_att_with_accept_gzip_encoding({text, _}, {Data, {_, _, AttUrl}}) ->
     ?_test(begin
         {ok, Code, Headers, Body} = test_request:get(
             AttUrl, [{"Accept-Encoding", "gzip"}]),
         ?assertEqual(200, Code),
         ?assert(lists:member({"Content-Encoding", "gzip"}, Headers)),
         ?assertEqual(Data, zlib:gunzip(iolist_to_binary(Body)))
     end);
 should_get_att_with_accept_gzip_encoding({binary, _}, {Data, {_, _, AttUrl}}) ->
     ?_test(begin
         {ok, Code, Headers, Body} = test_request:get(
             AttUrl, [{"Accept-Encoding", "gzip"}]),
         ?assertEqual(200, Code),
         ?assertEqual(undefined,
                      couch_util:get_value("Content-Encoding", Headers)),
         ?assertEqual(Data, iolist_to_binary(Body))
     end).

 should_get_att_with_accept_deflate_encoding(_, {Data, {_, _, AttUrl}}) ->
     ?_test(begin
         {ok, Code, Headers, Body} = test_request:get(
             AttUrl, [{"Accept-Encoding", "deflate"}]),
         ?assertEqual(200, Code),
         ?assertEqual(undefined,
                      couch_util:get_value("Content-Encoding", Headers)),
         ?assertEqual(Data, iolist_to_binary(Body))
     end).

 should_return_406_response_on_unsupported_encoding(_, {_, {_, _, AttUrl}}) ->
     ?_assertEqual(406,
         begin
             {ok, Code, _, _} = test_request:get(
                 AttUrl, [{"Accept-Encoding", "deflate, *;q=0"}]),
             Code
         end).

 should_get_doc_with_att_data(compressed, {Data, {_, DocUrl, _}}) ->
     ?_test(begin
         Url = DocUrl ++ "?attachments=true",
         {ok, Code, _, Body} = test_request:get(
             Url, [{"Accept", "application/json"}]),
         ?assertEqual(200, Code),
         Json = jiffy:decode(Body),
         AttJson = couch_util:get_nested_json_value(
             Json, [<<"_attachments">>, ?ATT_TXT_NAME]),
         AttData = couch_util:get_nested_json_value(
             AttJson, [<<"data">>]),
         ?assertEqual(
             <<"text/plain">>,
             couch_util:get_nested_json_value(AttJson,[<<"content_type">>])),
         ?assertEqual(Data, base64:decode(AttData))
     end);
 should_get_doc_with_att_data({text, _}, {Data, {_, DocUrl, _}}) ->
     ?_test(begin
         Url = DocUrl ++ "?attachments=true",
         {ok, Code, _, Body} = test_request:get(
             Url, [{"Accept", "application/json"}]),
         ?assertEqual(200, Code),
         Json = jiffy:decode(Body),
         AttJson = couch_util:get_nested_json_value(
             Json, [<<"_attachments">>, ?ATT_TXT_NAME]),
         AttData = couch_util:get_nested_json_value(
             AttJson, [<<"data">>]),
         ?assertEqual(
             <<"text/plain">>,
             couch_util:get_nested_json_value(AttJson,[<<"content_type">>])),
         ?assertEqual(Data, base64:decode(AttData))
     end);
 should_get_doc_with_att_data({binary, _}, {Data, {_, DocUrl, _}}) ->
     ?_test(begin
         Url = DocUrl ++ "?attachments=true",
         {ok, Code, _, Body} = test_request:get(
             Url, [{"Accept", "application/json"}]),
         ?assertEqual(200, Code),
         Json = jiffy:decode(Body),
         AttJson = couch_util:get_nested_json_value(
             Json, [<<"_attachments">>, ?ATT_BIN_NAME]),
         AttData = couch_util:get_nested_json_value(
             AttJson, [<<"data">>]),
         ?assertEqual(
             <<"image/png">>,
             couch_util:get_nested_json_value(AttJson,[<<"content_type">>])),
         ?assertEqual(Data, base64:decode(AttData))
     end).

 should_get_doc_with_att_data_stub(compressed, {Data, {_, DocUrl, _}}) ->
     ?_test(begin
         Url = DocUrl ++ "?att_encoding_info=true",
         {ok, Code, _, Body} = test_request:get(
             Url, [{"Accept", "application/json"}]),
         ?assertEqual(200, Code),
         Json = jiffy:decode(Body),
         {AttJson} = couch_util:get_nested_json_value(
             Json, [<<"_attachments">>, ?ATT_TXT_NAME]),
         ?assertEqual(<<"gzip">>,
                      couch_util:get_value(<<"encoding">>, AttJson)),
         AttLength = couch_util:get_value(<<"length">>, AttJson),
         EncLength = couch_util:get_value(<<"encoded_length">>, AttJson),
         ?assertEqual(AttLength, EncLength),
         ?assertEqual(iolist_size(zlib:gzip(Data)), AttLength)
     end);
 should_get_doc_with_att_data_stub({text, _}, {Data, {_, DocUrl, _}}) ->
     ?_test(begin
         Url = DocUrl ++ "?att_encoding_info=true",
         {ok, Code, _, Body} = test_request:get(
             Url, [{"Accept", "application/json"}]),
         ?assertEqual(200, Code),
         Json = jiffy:decode(Body),
         {AttJson} = couch_util:get_nested_json_value(
             Json, [<<"_attachments">>, ?ATT_TXT_NAME]),
         ?assertEqual(<<"gzip">>,
                      couch_util:get_value(<<"encoding">>, AttJson)),
         AttEncLength = iolist_size(gzip(Data)),
         ?assertEqual(AttEncLength,
                      couch_util:get_value(<<"encoded_length">>, AttJson)),
         ?assertEqual(byte_size(Data),
                      couch_util:get_value(<<"length">>, AttJson))
     end);
 should_get_doc_with_att_data_stub({binary, _}, {Data, {_, DocUrl, _}}) ->
     ?_test(begin
         Url = DocUrl ++ "?att_encoding_info=true",
         {ok, Code, _, Body} = test_request:get(
             Url, [{"Accept", "application/json"}]),
         ?assertEqual(200, Code),
         Json = jiffy:decode(Body),
         {AttJson} = couch_util:get_nested_json_value(
             Json, [<<"_attachments">>, ?ATT_BIN_NAME]),
         ?assertEqual(undefined,
                      couch_util:get_value(<<"encoding">>, AttJson)),
         ?assertEqual(undefined,
                      couch_util:get_value(<<"encoded_length">>, AttJson)),
         ?assertEqual(byte_size(Data),
                      couch_util:get_value(<<"length">>, AttJson))
     end).

 should_not_create_compressed_att_with_deflate_encoding({Host, DbName}) ->
     ?_assertEqual(415,
         begin
             HttpHost = "http://" ++ Host,
             AttUrl = string:join([HttpHost, DbName, ?docid(), "file.txt"], "/"),
             {ok, Data} = file:read_file(?FIXTURE_TXT),
             Body = zlib:compress(Data),
             Headers = [
                 {"Content-Encoding", "deflate"},
                 {"Content-Type", "text/plain"}
             ],
             {ok, Code, _, _} = test_request:put(AttUrl, Headers, Body),
             Code
         end).

 should_not_create_compressed_att_with_compress_encoding({Host, DbName}) ->
     % Note: As of OTP R13B04, it seems there's no LZW compression
     % (i.e. UNIX compress utility implementation) lib in OTP.
     % However there's a simple working Erlang implementation at:
     % http://scienceblogs.com/goodmath/2008/01/simple_lempelziv_compression_i.php
     ?_assertEqual(415,
         begin
             HttpHost = "http://" ++ Host,
             AttUrl = string:join([HttpHost, DbName, ?docid(), "file.txt"], "/"),
             {ok, Data} = file:read_file(?FIXTURE_TXT),
             Headers = [
                 {"Content-Encoding", "compress"},
                 {"Content-Type", "text/plain"}
             ],
             {ok, Code, _, _} = test_request:put(AttUrl, Headers, Data),
             Code
         end).

 should_create_compressible_att_with_ctype_params({Host, DbName}) ->
     {timeout, ?TIMEOUT_EUNIT, ?_test(begin
         HttpHost = "http://" ++ Host,
         DocUrl = string:join([HttpHost, DbName, ?docid()], "/"),
         AttUrl = string:join([DocUrl, ?b2l(?ATT_TXT_NAME)], "/"),
         {ok, Data} = file:read_file(?FIXTURE_TXT),
         Headers = [{"Content-Type", "text/plain; charset=UTF-8"}],
         {ok, Code0, _, _} = test_request:put(AttUrl, Headers, Data),
         ?assertEqual(201, Code0),

         {ok, Code1, _, Body} = test_request:get(
             DocUrl ++ "?att_encoding_info=true"),
         ?assertEqual(200, Code1),
         Json = jiffy:decode(Body),
         {AttJson} = couch_util:get_nested_json_value(
             Json, [<<"_attachments">>, ?ATT_TXT_NAME]),
         ?assertEqual(<<"gzip">>,
                      couch_util:get_value(<<"encoding">>, AttJson)),
         AttEncLength = iolist_size(gzip(Data)),
         ?assertEqual(AttEncLength,
                      couch_util:get_value(<<"encoded_length">>, AttJson)),
         ?assertEqual(byte_size(Data),
                      couch_util:get_value(<<"length">>, AttJson))
     end)}.


 get_json(Json, Path) ->
     couch_util:get_nested_json_value(Json, Path).

 to_hex(Val) ->
     to_hex(Val, []).

 to_hex(0, Acc) ->
     Acc;
 to_hex(Val, Acc) ->
     to_hex(Val div 16, [hex_char(Val rem 16) | Acc]).

 hex_char(V) when V < 10 -> $0 + V;
 hex_char(V) -> $A + V - 10.

 chunked_body(Chunks) ->
     chunked_body(Chunks, []).

 chunked_body([], Acc) ->
     iolist_to_binary(lists:reverse(Acc, "0\r\n"));
 chunked_body([Chunk | Rest], Acc) ->
     Size = to_hex(size(Chunk)),
     chunked_body(Rest, ["\r\n", Chunk, "\r\n", Size | Acc]).

 get_socket() ->
     Options = [binary, {packet, 0}, {active, false}],
     Port = mochiweb_socket_server:get(couch_httpd, port),
     {ok, Sock} = gen_tcp:connect(bind_address(), Port, Options),
     Sock.

 bind_address() ->
     case config:get("httpd", "bind_address") of
         undefined -> any;
         Address -> Address
     end.

 request(Method, Url, Headers, Body) ->
     RequestHead = [Method, " ", Url, " HTTP/1.1"],
     RequestHeaders = [[string:join([Key, Value], ": "), "\r\n"]
                       || {Key, Value} <- Headers],
     Request = [RequestHead, "\r\n", RequestHeaders, "\r\n", Body],
     Sock = get_socket(),
     gen_tcp:send(Sock, list_to_binary(lists:flatten(Request))),
     timer:sleep(?TIMEWAIT),  % must wait to receive complete response
     {ok, R} = gen_tcp:recv(Sock, 0),
     gen_tcp:close(Sock),
     [Header, Body1] = re:split(R, "\r\n\r\n", [{return, binary}]),
     {ok, {http_response, _, Code, _}, _} =
         erlang:decode_packet(http, Header, []),
     Json = jiffy:decode(Body1),
     {ok, Code, Json}.

 create_standalone_text_att(Host, DbName) ->
     {ok, Data} = file:read_file(?FIXTURE_TXT),
     Url = string:join([Host, DbName, "doc", ?b2l(?ATT_TXT_NAME)], "/"),
     {ok, Code, _Headers, _Body} = test_request:put(
         Url, [{"Content-Type", "text/plain"}], Data),
     ?assertEqual(201, Code),
     Url.

 create_standalone_png_att(Host, DbName) ->
     {ok, Data} = file:read_file(?FIXTURE_PNG),
     Url = string:join([Host, DbName, "doc", ?b2l(?ATT_BIN_NAME)], "/"),
     {ok, Code, _Headers, _Body} = test_request:put(
         Url, [{"Content-Type", "image/png"}], Data),
     ?assertEqual(201, Code),
     Url.

 create_inline_text_att(Host, DbName) ->
     {ok, Data} = file:read_file(?FIXTURE_TXT),
     Url = string:join([Host, DbName, "doc"], "/"),
     Doc = {[
         {<<"_attachments">>, {[
             {?ATT_TXT_NAME, {[
                 {<<"content_type">>, <<"text/plain">>},
                 {<<"data">>, base64:encode(Data)}
             ]}
         }]}}
     ]},
     {ok, Code, _Headers, _Body} = test_request:put(
         Url, [{"Content-Type", "application/json"}], jiffy:encode(Doc)),
     ?assertEqual(201, Code),
     string:join([Url, ?b2l(?ATT_TXT_NAME)], "/").

 create_inline_png_att(Host, DbName) ->
     {ok, Data} = file:read_file(?FIXTURE_PNG),
     Url = string:join([Host, DbName, "doc"], "/"),
     Doc = {[
         {<<"_attachments">>, {[
             {?ATT_BIN_NAME, {[
                 {<<"content_type">>, <<"image/png">>},
                 {<<"data">>, base64:encode(Data)}
             ]}
         }]}}
     ]},
     {ok, Code, _Headers, _Body} = test_request:put(
         Url, [{"Content-Type", "application/json"}], jiffy:encode(Doc)),
     ?assertEqual(201, Code),
     string:join([Url, ?b2l(?ATT_BIN_NAME)], "/").

 create_already_compressed_att(Host, DbName) ->
     {ok, Data} = file:read_file(?FIXTURE_TXT),
     Url = string:join([Host, DbName, "doc", ?b2l(?ATT_TXT_NAME)], "/"),
     {ok, Code, _Headers, _Body} = test_request:put(
         Url, [{"Content-Type", "text/plain"}, {"Content-Encoding", "gzip"}],
         zlib:gzip(Data)),
     ?assertEqual(201, Code),
     Url.

 gzip(Data) ->
     Z = zlib:open(),
     ok = zlib:deflateInit(Z, ?COMPRESSION_LEVEL, deflated, 16 + 15, 8, default),
     zlib:deflate(Z, Data),
     Last = zlib:deflate(Z, [], finish),
     ok = zlib:deflateEnd(Z),
     ok = zlib:close(Z),
     Last.
	% Licensed under the Apache License, Version 2.0 (the "License"); you may not
	% use this file except in compliance with the License. You may obtain a copy of
	% the License at
	%
	% http://www.apache.org/licenses/LICENSE-2.0
	%
	% Unless required by applicable law or agreed to in writing, software
	% distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
	% WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
	% License for the specific language governing permissions and limitations under
	% the License.

	-module(couchdb_attachments_tests).

	-include_lib("couch/include/couch_eunit.hrl").
	-include_lib("couch/include/couch_db.hrl").

	-define(COMPRESSION_LEVEL, 8).
	-define(ATT_BIN_NAME, <<"logo.png">>).
	-define(ATT_TXT_NAME, <<"file.erl">>).
	-define(FIXTURE_PNG, filename:join([?FIXTURESDIR, "logo.png"])).
	-define(FIXTURE_TXT, ?ABS_PATH(?FILE)).
	-define(TIMEOUT, 1000).
	-define(TIMEOUT_EUNIT, 10).
	-define(TIMEWAIT, 100).
	-define(i2l(I), integer_to_list(I)).


	start() ->
	Ctx = test_util:start_couch(),
	% ensure in default compression settings for attachments_compression_tests
	config:set("attachments", "compression_level",
	?i2l(?COMPRESSION_LEVEL), false),
	config:set("attachments", "compressible_types", "text/*", false),
	Ctx.

	setup() ->
	DbName = ?tempdb(),
	{ok, Db} = couch_db:create(DbName, []),
	ok = couch_db:close(Db),
	Addr = config:get("httpd", "bind_address", "127.0.0.1"),
	Port = mochiweb_socket_server:get(couch_httpd, port),
	Host = Addr ++ ":" ++ ?i2l(Port),
	{Host, ?b2l(DbName)}.

	setup({binary, standalone}) ->
	{Host, DbName} = setup(),
	setup_att(fun create_standalone_png_att/2, Host, DbName, ?FIXTURE_PNG);
	setup({text, standalone}) ->
	{Host, DbName} = setup(),
	setup_att(fun create_standalone_text_att/2, Host, DbName, ?FIXTURE_TXT);
	setup({binary, inline}) ->
	{Host, DbName} = setup(),
	setup_att(fun create_inline_png_att/2, Host, DbName, ?FIXTURE_PNG);
	setup({text, inline}) ->
	{Host, DbName} = setup(),
	setup_att(fun create_inline_text_att/2, Host, DbName, ?FIXTURE_TXT);
	setup(compressed) ->
	{Host, DbName} = setup(),
	setup_att(fun create_already_compressed_att/2, Host, DbName, ?FIXTURE_TXT).
	setup_att(Fun, Host, DbName, File) ->
	HttpHost = "http://" ++ Host,
	AttUrl = Fun(HttpHost, DbName),
	{ok, Data} = file:read_file(File),
	DocUrl = string:join([HttpHost, DbName, "doc"], "/"),
	Helpers = {DbName, DocUrl, AttUrl},
	{Data, Helpers}.

	teardown(_, {_, {DbName, _, _}}) ->
	teardown(DbName).

	teardown({_, DbName}) ->
	teardown(DbName);
	teardown(DbName) ->
	ok = couch_server:delete(?l2b(DbName), []),
	ok.


	attachments_test_() ->
	{
	"Attachments tests",
	{
	setup,
	fun start/0, fun test_util:stop_couch/1,
	[
	attachments_md5_tests(),
	attachments_compression_tests()
	]
	}
	}.

	attachments_md5_tests() ->
	{
	"Attachments MD5 tests",
	{
	foreach,
	fun setup/0, fun teardown/1,
	[
	fun should_upload_attachment_without_md5/1,
	fun should_upload_attachment_by_chunks_without_md5/1,
	fun should_upload_attachment_with_valid_md5_header/1,
	fun should_upload_attachment_by_chunks_with_valid_md5_header/1,
	fun should_upload_attachment_by_chunks_with_valid_md5_trailer/1,
	fun should_reject_attachment_with_invalid_md5/1,
	fun should_reject_chunked_attachment_with_invalid_md5/1,
	fun should_reject_chunked_attachment_with_invalid_md5_trailer/1
	]
	}
	}.

	attachments_compression_tests() ->
	Funs = [
	fun should_get_att_without_accept_gzip_encoding/2,
	fun should_get_att_with_accept_gzip_encoding/2,
	fun should_get_att_with_accept_deflate_encoding/2,
	fun should_return_406_response_on_unsupported_encoding/2,
	fun should_get_doc_with_att_data/2,
	fun should_get_doc_with_att_data_stub/2
	],
	{
	"Attachments compression tests",
	[
	{
	"Created via Attachments API",
	created_attachments_compression_tests(standalone, Funs)
	},
	{
	"Created inline via Document API",
	created_attachments_compression_tests(inline, Funs)
	},
	{
	"Created already been compressed via Attachments API",
	{
	foreachx,
	fun setup/1, fun teardown/2,
	[{compressed, Fun} \|\| Fun <- Funs]
	}
	},
	{
	foreach,
	fun setup/0, fun teardown/1,
	[
	fun should_not_create_compressed_att_with_deflate_encoding/1,
	fun should_not_create_compressed_att_with_compress_encoding/1,
	fun should_create_compressible_att_with_ctype_params/1
	]
	}
	]
	}.

	created_attachments_compression_tests(Mod, Funs) ->
	[
	{
	"Compressiable attachments",
	{
	foreachx,
	fun setup/1, fun teardown/2,
	[{{text, Mod}, Fun} \|\| Fun <- Funs]
	}
	},
	{
	"Uncompressiable attachments",
	{
	foreachx,
	fun setup/1, fun teardown/2,
	[{{binary, Mod}, Fun} \|\| Fun <- Funs]
	}
	}
	].



	should_upload_attachment_without_md5({Host, DbName}) ->
	?_test(begin
	AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
	Body = "We all live in a yellow submarine!",
	Headers = [
	{"Content-Length", "34"},
	{"Content-Type", "text/plain"},
	{"Host", Host}
	],
	{ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
	?assertEqual(201, Code),
	?assertEqual(true, get_json(Json, [<<"ok">>]))
	end).

	should_upload_attachment_by_chunks_without_md5({Host, DbName}) ->
	?_test(begin
	AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
	AttData = <<"We all live in a yellow submarine!">>,
	<<Part1:21/binary, Part2:13/binary>> = AttData,
	Body = [chunked_body([Part1, Part2]), "\r\n"],
	Headers = [
	{"Content-Type", "text/plain"},
	{"Transfer-Encoding", "chunked"},
	{"Host", Host}
	],
	{ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
	?assertEqual(201, Code),
	?assertEqual(true, get_json(Json, [<<"ok">>]))
	end).

	should_upload_attachment_with_valid_md5_header({Host, DbName}) ->
	?_test(begin
	AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
	Body = "We all live in a yellow submarine!",
	Headers = [
	{"Content-Length", "34"},
	{"Content-Type", "text/plain"},
	{"Content-MD5", ?b2l(base64:encode(couch_crypto:hash(md5, Body)))},
	{"Host", Host}
	],
	{ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
	?assertEqual(201, Code),
	?assertEqual(true, get_json(Json, [<<"ok">>]))
	end).

	should_upload_attachment_by_chunks_with_valid_md5_header({Host, DbName}) ->
	?_test(begin
	AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
	AttData = <<"We all live in a yellow submarine!">>,
	<<Part1:21/binary, Part2:13/binary>> = AttData,
	Body = [chunked_body([Part1, Part2]), "\r\n"],
	Headers = [
	{"Content-Type", "text/plain"},
	{"Content-MD5", ?b2l(base64:encode(couch_crypto:hash(md5, AttData)))},
	{"Host", Host},
	{"Transfer-Encoding", "chunked"}
	],
	{ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
	?assertEqual(201, Code),
	?assertEqual(true, get_json(Json, [<<"ok">>]))
	end).

	should_upload_attachment_by_chunks_with_valid_md5_trailer({Host, DbName}) ->
	?_test(begin
	AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
	AttData = <<"We all live in a yellow submarine!">>,
	<<Part1:21/binary, Part2:13/binary>> = AttData,
	Body = [chunked_body([Part1, Part2]),
	"Content-MD5: ", base64:encode(couch_crypto:hash(md5, AttData)),
	"\r\n\r\n"],
	Headers = [
	{"Content-Type", "text/plain"},
	{"Host", Host},
	{"Trailer", "Content-MD5"},
	{"Transfer-Encoding", "chunked"}
	],
	{ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
	?assertEqual(201, Code),
	?assertEqual(true, get_json(Json, [<<"ok">>]))
	end).

	should_reject_attachment_with_invalid_md5({Host, DbName}) ->
	?_test(begin
	AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
	Body = "We all live in a yellow submarine!",
	Headers = [
	{"Content-Length", "34"},
	{"Content-Type", "text/plain"},
	{"Content-MD5", ?b2l(base64:encode(<<"foobar!">>))},
	{"Host", Host}
	],
	{ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
	?assertEqual(400, Code),
	?assertEqual(<<"content_md5_mismatch">>,
	get_json(Json, [<<"error">>]))
	end).


	should_reject_chunked_attachment_with_invalid_md5({Host, DbName}) ->
	?_test(begin
	AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
	AttData = <<"We all live in a yellow submarine!">>,
	<<Part1:21/binary, Part2:13/binary>> = AttData,
	Body = [chunked_body([Part1, Part2]), "\r\n"],
	Headers = [
	{"Content-Type", "text/plain"},
	{"Content-MD5", ?b2l(base64:encode(<<"foobar!">>))},
	{"Host", Host},
	{"Transfer-Encoding", "chunked"}
	],
	{ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
	?assertEqual(400, Code),
	?assertEqual(<<"content_md5_mismatch">>,
	get_json(Json, [<<"error">>]))
	end).

	should_reject_chunked_attachment_with_invalid_md5_trailer({Host, DbName}) ->
	?_test(begin
	AttUrl = string:join(["", DbName, ?docid(), "readme.txt"], "/"),
	AttData = <<"We all live in a yellow submarine!">>,
	<<Part1:21/binary, Part2:13/binary>> = AttData,
	Body = [chunked_body([Part1, Part2]),
	"Content-MD5: ", base64:encode(<<"foobar!">>),
	"\r\n\r\n"],
	Headers = [
	{"Content-Type", "text/plain"},
	{"Host", Host},
	{"Trailer", "Content-MD5"},
	{"Transfer-Encoding", "chunked"}
	],
	{ok, Code, Json} = request("PUT", AttUrl, Headers, Body),
	?assertEqual(400, Code),
	?assertEqual(<<"content_md5_mismatch">>, get_json(Json, [<<"error">>]))
	end).

	should_get_att_without_accept_gzip_encoding(_, {Data, {_, _, AttUrl}}) ->
	?_test(begin
	{ok, Code, Headers, Body} = test_request:get(AttUrl),
	?assertEqual(200, Code),
	?assertNot(lists:member({"Content-Encoding", "gzip"}, Headers)),
	?assertEqual(Data, iolist_to_binary(Body))
	end).

	should_get_att_with_accept_gzip_encoding(compressed, {Data, {_, _, AttUrl}}) ->
	?_test(begin
	{ok, Code, Headers, Body} = test_request:get(
	AttUrl, [{"Accept-Encoding", "gzip"}]),
	?assertEqual(200, Code),
	?assert(lists:member({"Content-Encoding", "gzip"}, Headers)),
	?assertEqual(Data, zlib:gunzip(iolist_to_binary(Body)))
	end);
	should_get_att_with_accept_gzip_encoding({text, _}, {Data, {_, _, AttUrl}}) ->
	?_test(begin
	{ok, Code, Headers, Body} = test_request:get(
	AttUrl, [{"Accept-Encoding", "gzip"}]),
	?assertEqual(200, Code),
	?assert(lists:member({"Content-Encoding", "gzip"}, Headers)),
	?assertEqual(Data, zlib:gunzip(iolist_to_binary(Body)))
	end);
	should_get_att_with_accept_gzip_encoding({binary, _}, {Data, {_, _, AttUrl}}) ->
	?_test(begin
	{ok, Code, Headers, Body} = test_request:get(
	AttUrl, [{"Accept-Encoding", "gzip"}]),
	?assertEqual(200, Code),
	?assertEqual(undefined,
	couch_util:get_value("Content-Encoding", Headers)),
	?assertEqual(Data, iolist_to_binary(Body))
	end).

	should_get_att_with_accept_deflate_encoding(_, {Data, {_, _, AttUrl}}) ->
	?_test(begin
	{ok, Code, Headers, Body} = test_request:get(
	AttUrl, [{"Accept-Encoding", "deflate"}]),
	?assertEqual(200, Code),
	?assertEqual(undefined,
	couch_util:get_value("Content-Encoding", Headers)),
	?assertEqual(Data, iolist_to_binary(Body))
	end).

	should_return_406_response_on_unsupported_encoding(_, {_, {_, _, AttUrl}}) ->
	?_assertEqual(406,
	begin
	{ok, Code, _, _} = test_request:get(
	AttUrl, [{"Accept-Encoding", "deflate, *;q=0"}]),
	Code
	end).

	should_get_doc_with_att_data(compressed, {Data, {_, DocUrl, _}}) ->
	?_test(begin
	Url = DocUrl ++ "?attachments=true",
	{ok, Code, _, Body} = test_request:get(
	Url, [{"Accept", "application/json"}]),
	?assertEqual(200, Code),
	Json = jiffy:decode(Body),
	AttJson = couch_util:get_nested_json_value(
	Json, [<<"_attachments">>, ?ATT_TXT_NAME]),
	AttData = couch_util:get_nested_json_value(
	AttJson, [<<"data">>]),
	?assertEqual(
	<<"text/plain">>,
	couch_util:get_nested_json_value(AttJson,[<<"content_type">>])),
	?assertEqual(Data, base64:decode(AttData))
	end);
	should_get_doc_with_att_data({text, _}, {Data, {_, DocUrl, _}}) ->
	?_test(begin
	Url = DocUrl ++ "?attachments=true",
	{ok, Code, _, Body} = test_request:get(
	Url, [{"Accept", "application/json"}]),
	?assertEqual(200, Code),
	Json = jiffy:decode(Body),
	AttJson = couch_util:get_nested_json_value(
	Json, [<<"_attachments">>, ?ATT_TXT_NAME]),
	AttData = couch_util:get_nested_json_value(
	AttJson, [<<"data">>]),
	?assertEqual(
	<<"text/plain">>,
	couch_util:get_nested_json_value(AttJson,[<<"content_type">>])),
	?assertEqual(Data, base64:decode(AttData))
	end);
	should_get_doc_with_att_data({binary, _}, {Data, {_, DocUrl, _}}) ->
	?_test(begin
	Url = DocUrl ++ "?attachments=true",
	{ok, Code, _, Body} = test_request:get(
	Url, [{"Accept", "application/json"}]),
	?assertEqual(200, Code),
	Json = jiffy:decode(Body),
	AttJson = couch_util:get_nested_json_value(
	Json, [<<"_attachments">>, ?ATT_BIN_NAME]),
	AttData = couch_util:get_nested_json_value(
	AttJson, [<<"data">>]),
	?assertEqual(
	<<"image/png">>,
	couch_util:get_nested_json_value(AttJson,[<<"content_type">>])),
	?assertEqual(Data, base64:decode(AttData))
	end).

	should_get_doc_with_att_data_stub(compressed, {Data, {_, DocUrl, _}}) ->
	?_test(begin
	Url = DocUrl ++ "?att_encoding_info=true",
	{ok, Code, _, Body} = test_request:get(
	Url, [{"Accept", "application/json"}]),
	?assertEqual(200, Code),
	Json = jiffy:decode(Body),
	{AttJson} = couch_util:get_nested_json_value(
	Json, [<<"_attachments">>, ?ATT_TXT_NAME]),
	?assertEqual(<<"gzip">>,
	couch_util:get_value(<<"encoding">>, AttJson)),
	AttLength = couch_util:get_value(<<"length">>, AttJson),
	EncLength = couch_util:get_value(<<"encoded_length">>, AttJson),
	?assertEqual(AttLength, EncLength),
	?assertEqual(iolist_size(zlib:gzip(Data)), AttLength)
	end);
	should_get_doc_with_att_data_stub({text, _}, {Data, {_, DocUrl, _}}) ->
	?_test(begin
	Url = DocUrl ++ "?att_encoding_info=true",
	{ok, Code, _, Body} = test_request:get(
	Url, [{"Accept", "application/json"}]),
	?assertEqual(200, Code),
	Json = jiffy:decode(Body),
	{AttJson} = couch_util:get_nested_json_value(
	Json, [<<"_attachments">>, ?ATT_TXT_NAME]),
	?assertEqual(<<"gzip">>,
	couch_util:get_value(<<"encoding">>, AttJson)),
	AttEncLength = iolist_size(gzip(Data)),
	?assertEqual(AttEncLength,
	couch_util:get_value(<<"encoded_length">>, AttJson)),
	?assertEqual(byte_size(Data),
	couch_util:get_value(<<"length">>, AttJson))
	end);
	should_get_doc_with_att_data_stub({binary, _}, {Data, {_, DocUrl, _}}) ->
	?_test(begin
	Url = DocUrl ++ "?att_encoding_info=true",
	{ok, Code, _, Body} = test_request:get(
	Url, [{"Accept", "application/json"}]),
	?assertEqual(200, Code),
	Json = jiffy:decode(Body),
	{AttJson} = couch_util:get_nested_json_value(
	Json, [<<"_attachments">>, ?ATT_BIN_NAME]),
	?assertEqual(undefined,
	couch_util:get_value(<<"encoding">>, AttJson)),
	?assertEqual(undefined,
	couch_util:get_value(<<"encoded_length">>, AttJson)),
	?assertEqual(byte_size(Data),
	couch_util:get_value(<<"length">>, AttJson))
	end).

	should_not_create_compressed_att_with_deflate_encoding({Host, DbName}) ->
	?_assertEqual(415,
	begin
	HttpHost = "http://" ++ Host,
	AttUrl = string:join([HttpHost, DbName, ?docid(), "file.txt"], "/"),
	{ok, Data} = file:read_file(?FIXTURE_TXT),
	Body = zlib:compress(Data),
	Headers = [
	{"Content-Encoding", "deflate"},
	{"Content-Type", "text/plain"}
	],
	{ok, Code, _, _} = test_request:put(AttUrl, Headers, Body),
	Code
	end).

	should_not_create_compressed_att_with_compress_encoding({Host, DbName}) ->
	% Note: As of OTP R13B04, it seems there's no LZW compression
	% (i.e. UNIX compress utility implementation) lib in OTP.
	% However there's a simple working Erlang implementation at:
	% http://scienceblogs.com/goodmath/2008/01/simple_lempelziv_compression_i.php
	?_assertEqual(415,
	begin
	HttpHost = "http://" ++ Host,
	AttUrl = string:join([HttpHost, DbName, ?docid(), "file.txt"], "/"),
	{ok, Data} = file:read_file(?FIXTURE_TXT),
	Headers = [
	{"Content-Encoding", "compress"},
	{"Content-Type", "text/plain"}
	],
	{ok, Code, _, _} = test_request:put(AttUrl, Headers, Data),
	Code
	end).

	should_create_compressible_att_with_ctype_params({Host, DbName}) ->
	{timeout, ?TIMEOUT_EUNIT, ?_test(begin
	HttpHost = "http://" ++ Host,
	DocUrl = string:join([HttpHost, DbName, ?docid()], "/"),
	AttUrl = string:join([DocUrl, ?b2l(?ATT_TXT_NAME)], "/"),
	{ok, Data} = file:read_file(?FIXTURE_TXT),
	Headers = [{"Content-Type", "text/plain; charset=UTF-8"}],
	{ok, Code0, _, _} = test_request:put(AttUrl, Headers, Data),
	?assertEqual(201, Code0),

	{ok, Code1, _, Body} = test_request:get(
	DocUrl ++ "?att_encoding_info=true"),
	?assertEqual(200, Code1),
	Json = jiffy:decode(Body),
	{AttJson} = couch_util:get_nested_json_value(
	Json, [<<"_attachments">>, ?ATT_TXT_NAME]),
	?assertEqual(<<"gzip">>,
	couch_util:get_value(<<"encoding">>, AttJson)),
	AttEncLength = iolist_size(gzip(Data)),
	?assertEqual(AttEncLength,
	couch_util:get_value(<<"encoded_length">>, AttJson)),
	?assertEqual(byte_size(Data),
	couch_util:get_value(<<"length">>, AttJson))
	end)}.


	get_json(Json, Path) ->
	couch_util:get_nested_json_value(Json, Path).

	to_hex(Val) ->
	to_hex(Val, []).

	to_hex(0, Acc) ->
	Acc;
	to_hex(Val, Acc) ->
	to_hex(Val div 16, [hex_char(Val rem 16) \| Acc]).

	hex_char(V) when V < 10 -> $0 + V;
	hex_char(V) -> $A + V - 10.

	chunked_body(Chunks) ->
	chunked_body(Chunks, []).

	chunked_body([], Acc) ->
	iolist_to_binary(lists:reverse(Acc, "0\r\n"));
	chunked_body([Chunk \| Rest], Acc) ->
	Size = to_hex(size(Chunk)),
	chunked_body(Rest, ["\r\n", Chunk, "\r\n", Size \| Acc]).

	get_socket() ->
	Options = [binary, {packet, 0}, {active, false}],
	Port = mochiweb_socket_server:get(couch_httpd, port),
	{ok, Sock} = gen_tcp:connect(bind_address(), Port, Options),
	Sock.

	bind_address() ->
	case config:get("httpd", "bind_address") of
	undefined -> any;
	Address -> Address
	end.

	request(Method, Url, Headers, Body) ->
	RequestHead = [Method, " ", Url, " HTTP/1.1"],
	RequestHeaders = [[string:join([Key, Value], ": "), "\r\n"]
	\|\| {Key, Value} <- Headers],
	Request = [RequestHead, "\r\n", RequestHeaders, "\r\n", Body],
	Sock = get_socket(),
	gen_tcp:send(Sock, list_to_binary(lists:flatten(Request))),
	timer:sleep(?TIMEWAIT), % must wait to receive complete response
	{ok, R} = gen_tcp:recv(Sock, 0),
	gen_tcp:close(Sock),
	[Header, Body1] = re:split(R, "\r\n\r\n", [{return, binary}]),
	{ok, {http_response, _, Code, _}, _} =
	erlang:decode_packet(http, Header, []),
	Json = jiffy:decode(Body1),
	{ok, Code, Json}.

	create_standalone_text_att(Host, DbName) ->
	{ok, Data} = file:read_file(?FIXTURE_TXT),
	Url = string:join([Host, DbName, "doc", ?b2l(?ATT_TXT_NAME)], "/"),
	{ok, Code, _Headers, _Body} = test_request:put(
	Url, [{"Content-Type", "text/plain"}], Data),
	?assertEqual(201, Code),
	Url.

	create_standalone_png_att(Host, DbName) ->
	{ok, Data} = file:read_file(?FIXTURE_PNG),
	Url = string:join([Host, DbName, "doc", ?b2l(?ATT_BIN_NAME)], "/"),
	{ok, Code, _Headers, _Body} = test_request:put(
	Url, [{"Content-Type", "image/png"}], Data),
	?assertEqual(201, Code),
	Url.

	create_inline_text_att(Host, DbName) ->
	{ok, Data} = file:read_file(?FIXTURE_TXT),
	Url = string:join([Host, DbName, "doc"], "/"),
	Doc = {[
	{<<"_attachments">>, {[
	{?ATT_TXT_NAME, {[
	{<<"content_type">>, <<"text/plain">>},
	{<<"data">>, base64:encode(Data)}
	]}
	}]}}
	]},
	{ok, Code, _Headers, _Body} = test_request:put(
	Url, [{"Content-Type", "application/json"}], jiffy:encode(Doc)),
	?assertEqual(201, Code),
	string:join([Url, ?b2l(?ATT_TXT_NAME)], "/").

	create_inline_png_att(Host, DbName) ->
	{ok, Data} = file:read_file(?FIXTURE_PNG),
	Url = string:join([Host, DbName, "doc"], "/"),
	Doc = {[
	{<<"_attachments">>, {[
	{?ATT_BIN_NAME, {[
	{<<"content_type">>, <<"image/png">>},
	{<<"data">>, base64:encode(Data)}
	]}
	}]}}
	]},
	{ok, Code, _Headers, _Body} = test_request:put(
	Url, [{"Content-Type", "application/json"}], jiffy:encode(Doc)),
	?assertEqual(201, Code),
	string:join([Url, ?b2l(?ATT_BIN_NAME)], "/").

	create_already_compressed_att(Host, DbName) ->
	{ok, Data} = file:read_file(?FIXTURE_TXT),
	Url = string:join([Host, DbName, "doc", ?b2l(?ATT_TXT_NAME)], "/"),
	{ok, Code, _Headers, _Body} = test_request:put(
	Url, [{"Content-Type", "text/plain"}, {"Content-Encoding", "gzip"}],
	zlib:gzip(Data)),
	?assertEqual(201, Code),
	Url.

	gzip(Data) ->
	Z = zlib:open(),
	ok = zlib:deflateInit(Z, ?COMPRESSION_LEVEL, deflated, 16 + 15, 8, default),
	zlib:deflate(Z, Data),
	Last = zlib:deflate(Z, [], finish),
	ok = zlib:deflateEnd(Z),
	ok = zlib:close(Z),
	Last.