% 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_access_tests).

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

-define(CONTENT_JSON, {"Content-Type", "application/json"}).
-define(ADMIN_REQ_HEADERS, [?CONTENT_JSON, {basic_auth, {"a", "a"}}]).
-define(USERX_REQ_HEADERS, [?CONTENT_JSON, {basic_auth, {"x", "x"}}]).
-define(USERY_REQ_HEADERS, [?CONTENT_JSON, {basic_auth, {"y", "y"}}]).
-define(SECURITY_OBJECT,
    {[
        {<<"members">>, {[{<<"roles">>, [<<"_admin">>, <<"_users">>]}]}},
        {<<"admins">>, {[{<<"roles">>, [<<"_admin">>]}]}}
    ]}
).

url() ->
    Addr = config:get("httpd", "bind_address", "127.0.0.1"),
    lists:concat(["http://", Addr, ":", port()]).

before_each(_) ->
    R = test_request:put(url() ++ "/db?q=1&n=1&access=true", ?ADMIN_REQ_HEADERS, ""),
    %?debugFmt("~nRequest: ~p~n", [R]),
    {ok, 201, _, _} = R,
    {ok, _, _, _} = test_request:put(
        url() ++ "/db/_security", ?ADMIN_REQ_HEADERS, jiffy:encode(?SECURITY_OBJECT)
    ),
    url().

after_each(_, Url) ->
    {ok, 200, _, _} = test_request:delete(Url ++ "/db", ?ADMIN_REQ_HEADERS),
    {_, _, _, _} = test_request:delete(Url ++ "/db2", ?ADMIN_REQ_HEADERS),
    {_, _, _, _} = test_request:delete(Url ++ "/db3", ?ADMIN_REQ_HEADERS),
    ok.

before_all() ->
    Couch = test_util:start_couch([chttpd, couch_replicator]),
    Hashed = couch_passwords:hash_admin_password("a"),
    ok = config:set("admins", "a", binary_to_list(Hashed), false),
    ok = config:set("couchdb", "uuid", "21ac467c1bc05e9d9e9d2d850bb1108f", false),
    ok = config:set("log", "level", "debug", false),
    ok = config:set("per_doc_access", "enable", "true", false),

    % cleanup and setup
    {ok, _, _, _} = test_request:delete(url() ++ "/db", ?ADMIN_REQ_HEADERS),
    % {ok, _, _, _} = test_request:put(url() ++ "/db?q=1&n=1&access=true", ?ADMIN_REQ_HEADERS, ""),

    % create users
    UserDbUrl = url() ++ "/_users?q=1&n=1",
    {ok, _, _, _} = test_request:delete(UserDbUrl, ?ADMIN_REQ_HEADERS, ""),
    {ok, 201, _, _} = test_request:put(UserDbUrl, ?ADMIN_REQ_HEADERS, ""),

    UserXDocUrl = url() ++ "/_users/org.couchdb.user:x",
    UserXDocBody = "{ \"name\":\"x\", \"roles\": [], \"password\":\"x\", \"type\": \"user\" }",
    {ok, 201, _, _} = test_request:put(UserXDocUrl, ?ADMIN_REQ_HEADERS, UserXDocBody),

    UserYDocUrl = url() ++ "/_users/org.couchdb.user:y",
    UserYDocBody = "{ \"name\":\"y\", \"roles\": [], \"password\":\"y\", \"type\": \"user\" }",
    {ok, 201, _, _} = test_request:put(UserYDocUrl, ?ADMIN_REQ_HEADERS, UserYDocBody),
    Couch.

after_all(_) ->
    UserDbUrl = url() ++ "/_users",
    {ok, _, _, _} = test_request:delete(UserDbUrl, ?ADMIN_REQ_HEADERS, ""),
    ok = test_util:stop_couch(done).

access_test_() ->
    Tests = [
        % Server config
        fun should_not_let_create_access_db_if_disabled/2,

        % Doc creation
        fun should_not_let_anonymous_user_create_doc/2,
        fun should_let_admin_create_doc_with_access/2,
        fun should_let_admin_create_doc_without_access/2,
        fun should_let_user_create_doc_for_themselves/2,
        fun should_not_let_user_create_doc_for_someone_else/2,
        fun should_let_user_create_access_ddoc/2,
        fun access_ddoc_should_have_no_effects/2,

        % Doc updates
        fun users_with_access_can_update_doc/2,
        fun users_without_access_can_not_update_doc/2,
        fun users_with_access_can_not_change_access/2,
        fun users_with_access_can_not_remove_access/2,

        % Doc reads
        fun should_let_admin_read_doc_with_access/2,
        fun user_with_access_can_read_doc/2,
        fun user_without_access_can_not_read_doc/2,
        fun user_can_not_read_doc_without_access/2,

        % Doc deletes
        fun should_let_admin_delete_doc_with_access/2,
        fun should_let_user_delete_doc_for_themselves/2,
        fun should_not_let_user_delete_doc_for_someone_else/2,

        % _all_docs with include_docs
        fun should_let_admin_fetch_all_docs/2,
        fun should_let_user_fetch_their_own_all_docs/2,

        % _changes
        fun should_let_admin_fetch_changes/2,
        fun should_let_user_fetch_their_own_changes/2,

        % views
        fun should_not_allow_admin_access_ddoc_view_request/2,
        fun should_not_allow_user_access_ddoc_view_request/2,
        fun should_allow_admin_users_access_ddoc_view_request/2,
        fun should_allow_user_users_access_ddoc_view_request/2,

        % replication
        fun should_allow_admin_to_replicate_from_access_to_access/2,
        fun should_allow_admin_to_replicate_from_no_access_to_access/2,
        fun should_allow_admin_to_replicate_from_access_to_no_access/2,
        fun should_allow_admin_to_replicate_from_no_access_to_no_access/2,

        fun should_allow_user_to_replicate_from_access_to_access/2,
        fun should_allow_user_to_replicate_from_access_to_no_access/2,
        fun should_allow_user_to_replicate_from_no_access_to_access/2,
        fun should_allow_user_to_replicate_from_no_access_to_no_access/2,

        % _revs_diff for docs you don’t have access to
        fun should_not_allow_user_to_revs_diff_other_docs/2

        % TODO: create test db with role and not _users in _security.members
        % and make sure a user in that group can access while a user not
        % in that group cant
        % % potential future feature
        % % fun should_let_user_fetch_their_own_all_docs_plus_users_ddocs/2%,
    ],
    {
        "Access tests",
        {
            setup,
            fun before_all/0,
            fun after_all/1,
            [
                make_test_cases(basic, Tests)
            ]
        }
    }.

make_test_cases(Mod, Funs) ->
    {
        lists:flatten(io_lib:format("~s", [Mod])),
        {foreachx, fun before_each/1, fun after_each/2, [{Mod, Fun} || Fun <- Funs]}
    }.

% Doc creation
% http://127.0.0.1:64903/db/a?revs=true&open_revs=%5B%221-23202479633c2b380f79507a776743d5%22%5D&latest=true

% should_do_the_thing(_PortType, Url) ->
%   ?_test(begin
%       {ok, _, _, _} = test_request:put(Url ++ "/db/a",
%           ?ADMIN_REQ_HEADERS, "{\"a\":1,\"_access\":[\"x\"]}"),
%       {ok, Code, _, _} = test_request:get(Url ++ "/db/a?revs=true&open_revs=%5B%221-23202479633c2b380f79507a776743d5%22%5D&latest=true",
%           ?USERX_REQ_HEADERS),
%       ?assertEqual(200, Code)
%   end).
%

should_not_let_create_access_db_if_disabled(_PortType, Url) ->
    ok = config:set("per_doc_access", "enable", "false", false),
    {ok, Code, _, _} = test_request:put(url() ++ "/db?q=1&n=1&access=true", ?ADMIN_REQ_HEADERS, ""),
    ok = config:set("per_doc_access", "enable", "true", false),
    ?_assertEqual(400, Code).

should_not_let_anonymous_user_create_doc(_PortType, Url) ->
    % TODO: debugging leftover
    % BulkDocsBody = {[
    %   {<<"docs">>, [
    %       {[{<<"_id">>, <<"a">>}]},
    %       {[{<<"_id">>, <<"a">>}]},
    %       {[{<<"_id">>, <<"b">>}]},
    %       {[{<<"_id">>, <<"c">>}]}
    %   ]}
    % ]},
    % Resp = test_request:post(Url ++ "/db/_bulk_docs", ?ADMIN_REQ_HEADERS, jiffy:encode(BulkDocsBody)),
    % ?debugFmt("~nResp: ~p~n", [Resp]),
    {ok, Code, _, _} = test_request:put(Url ++ "/db/a", "{\"a\":1,\"_access\":[\"x\"]}"),
    ?_assertEqual(401, Code).

should_let_admin_create_doc_with_access(_PortType, Url) ->
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/a",
        ?ADMIN_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    ?_assertEqual(201, Code).

should_let_admin_create_doc_without_access(_PortType, Url) ->
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/a",
        ?ADMIN_REQ_HEADERS,
        "{\"a\":1}"
    ),
    ?_assertEqual(201, Code).

should_let_user_create_doc_for_themselves(_PortType, Url) ->
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/b",
        ?USERX_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    ?_assertEqual(201, Code).

should_not_let_user_create_doc_for_someone_else(_PortType, Url) ->
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/c",
        ?USERY_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    ?_assertEqual(403, Code).

should_let_user_create_access_ddoc(_PortType, Url) ->
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/_design/dx",
        ?USERX_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    ?_assertEqual(201, Code).

access_ddoc_should_have_no_effects(_PortType, Url) ->
    ?_test(begin
        Ddoc =
            "{ \"_access\":[\"x\"], \"validate_doc_update\": \"function(newDoc, oldDoc, userCtx) { throw({unauthorized: 'throw error'})}\",   \"views\": {     \"foo\": {       \"map\": \"function(doc) { emit(doc._id) }\"     }   },   \"shows\": {     \"boo\": \"function() {}\"   },   \"lists\": {    \"hoo\": \"function() {}\"   },   \"update\": {     \"goo\": \"function() {}\"   },   \"filters\": {     \"loo\": \"function() {}\"   }   }",
        {ok, Code, _, _} = test_request:put(
            Url ++ "/db/_design/dx",
            ?USERX_REQ_HEADERS,
            Ddoc
        ),
        ?assertEqual(201, Code),
        {ok, Code1, _, B} = test_request:put(
            Url ++ "/db/b",
            ?USERX_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        ?assertEqual(201, Code1),
        {ok, Code2, _, _} = test_request:get(
            Url ++ "/db/_design/dx/_view/foo",
            ?USERX_REQ_HEADERS
        ),
        ?assertEqual(404, Code2),
        {ok, Code3, _, _} = test_request:get(
            Url ++ "/db/_design/dx/_show/boo/b",
            ?USERX_REQ_HEADERS
        ),
        ?assertEqual(404, Code3),
        {ok, Code4, _, _} = test_request:get(
            Url ++ "/db/_design/dx/_list/hoo/foo",
            ?USERX_REQ_HEADERS
        ),
        ?assertEqual(404, Code4),
        {ok, Code5, _, _} = test_request:post(
            Url ++ "/db/_design/dx/_update/goo",
            ?USERX_REQ_HEADERS,
            ""
        ),
        ?assertEqual(404, Code5),
        {ok, Code6, _, _} = test_request:get(
            Url ++ "/db/_changes?filter=dx/loo",
            ?USERX_REQ_HEADERS
        ),
        ?assertEqual(404, Code6),
        {ok, Code7, _, _} = test_request:get(
            Url ++ "/db/_changes?filter=_view&view=dx/foo",
            ?USERX_REQ_HEADERS
        ),
        ?assertEqual(404, Code7)
    end).

% Doc updates

users_with_access_can_update_doc(_PortType, Url) ->
    {ok, _, _, Body} = test_request:put(
        Url ++ "/db/b",
        ?USERX_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {Json} = jiffy:decode(Body),
    Rev = couch_util:get_value(<<"rev">>, Json),
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/b",
        ?USERX_REQ_HEADERS,
        "{\"a\":2,\"_access\":[\"x\"],\"_rev\":\"" ++ binary_to_list(Rev) ++ "\"}"
    ),
    ?_assertEqual(201, Code).

users_without_access_can_not_update_doc(_PortType, Url) ->
    {ok, _, _, Body} = test_request:put(
        Url ++ "/db/b",
        ?USERX_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {Json} = jiffy:decode(Body),
    Rev = couch_util:get_value(<<"rev">>, Json),
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/b",
        ?USERY_REQ_HEADERS,
        "{\"a\":2,\"_access\":[\"y\"],\"_rev\":\"" ++ binary_to_list(Rev) ++ "\"}"
    ),
    ?_assertEqual(403, Code).

users_with_access_can_not_change_access(_PortType, Url) ->
    {ok, _, _, Body} = test_request:put(
        Url ++ "/db/b",
        ?USERX_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {Json} = jiffy:decode(Body),
    Rev = couch_util:get_value(<<"rev">>, Json),
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/b",
        ?USERX_REQ_HEADERS,
        "{\"a\":2,\"_access\":[\"y\"],\"_rev\":\"" ++ binary_to_list(Rev) ++ "\"}"
    ),
    ?_assertEqual(403, Code).

users_with_access_can_not_remove_access(_PortType, Url) ->
    {ok, _, _, Body} = test_request:put(
        Url ++ "/db/b",
        ?USERX_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {Json} = jiffy:decode(Body),
    Rev = couch_util:get_value(<<"rev">>, Json),
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/b",
        ?USERX_REQ_HEADERS,
        "{\"a\":2,\"_rev\":\"" ++ binary_to_list(Rev) ++ "\"}"
    ),
    ?_assertEqual(403, Code).

% Doc reads

should_let_admin_read_doc_with_access(_PortType, Url) ->
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/a",
        ?USERX_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {ok, Code, _, _} = test_request:get(
        Url ++ "/db/a",
        ?ADMIN_REQ_HEADERS
    ),
    ?_assertEqual(200, Code).

user_with_access_can_read_doc(_PortType, Url) ->
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/a",
        ?ADMIN_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {ok, Code, _, _} = test_request:get(
        Url ++ "/db/a",
        ?USERX_REQ_HEADERS
    ),
    ?_assertEqual(200, Code).

user_without_access_can_not_read_doc(_PortType, Url) ->
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/a",
        ?ADMIN_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {ok, Code, _, _} = test_request:get(
        Url ++ "/db/a",
        ?USERY_REQ_HEADERS
    ),
    ?_assertEqual(403, Code).

user_can_not_read_doc_without_access(_PortType, Url) ->
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/a",
        ?ADMIN_REQ_HEADERS,
        "{\"a\":1}"
    ),
    {ok, Code, _, _} = test_request:get(
        Url ++ "/db/a",
        ?USERX_REQ_HEADERS
    ),
    ?_assertEqual(403, Code).

% Doc deletes

should_let_admin_delete_doc_with_access(_PortType, Url) ->
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/a",
        ?USERX_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {ok, Code, _, _} = test_request:delete(
        Url ++ "/db/a?rev=1-23202479633c2b380f79507a776743d5",
        ?ADMIN_REQ_HEADERS
    ),
    ?_assertEqual(200, Code).

should_let_user_delete_doc_for_themselves(_PortType, Url) ->
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/a",
        ?USERX_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {ok, _, _, _} = test_request:get(
        Url ++ "/db/a",
        ?USERX_REQ_HEADERS
    ),
    {ok, Code, _, _} = test_request:delete(
        Url ++ "/db/a?rev=1-23202479633c2b380f79507a776743d5",
        ?USERX_REQ_HEADERS
    ),
    ?_assertEqual(200, Code).

should_not_let_user_delete_doc_for_someone_else(_PortType, Url) ->
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/a",
        ?USERX_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {ok, Code, _, _} = test_request:delete(
        Url ++ "/db/a?rev=1-23202479633c2b380f79507a776743d5",
        ?USERY_REQ_HEADERS
    ),
    ?_assertEqual(403, Code).

% _all_docs with include_docs

should_let_admin_fetch_all_docs(_PortType, Url) ->
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/a",
        ?ADMIN_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/b",
        ?ADMIN_REQ_HEADERS,
        "{\"b\":2,\"_access\":[\"x\"]}"
    ),
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/c",
        ?ADMIN_REQ_HEADERS,
        "{\"c\":3,\"_access\":[\"y\"]}"
    ),
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/d",
        ?ADMIN_REQ_HEADERS,
        "{\"d\":4,\"_access\":[\"y\"]}"
    ),
    {ok, 200, _, Body} = test_request:get(
        Url ++ "/db/_all_docs?include_docs=true",
        ?ADMIN_REQ_HEADERS
    ),
    {Json} = jiffy:decode(Body),
    ?_assertEqual(4, proplists:get_value(<<"total_rows">>, Json)).

should_let_user_fetch_their_own_all_docs(_PortType, Url) ->
    ?_test(begin
        {ok, 201, _, _} = test_request:put(
            Url ++ "/db/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, 201, _, _} = test_request:put(
            Url ++ "/db/b",
            ?USERX_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, 201, _, _} = test_request:put(
            Url ++ "/db/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"y\"]}"
        ),
        {ok, 201, _, _} = test_request:put(
            Url ++ "/db/d",
            ?USERY_REQ_HEADERS,
            "{\"d\":4,\"_access\":[\"y\"]}"
        ),
        {ok, 200, _, Body} = test_request:get(
            Url ++ "/db/_all_docs?include_docs=true",
            ?USERX_REQ_HEADERS
        ),
        {Json} = jiffy:decode(Body),
        Rows = proplists:get_value(<<"rows">>, Json),
        ?assertEqual(
            [
                {[
                    {<<"id">>, <<"a">>},
                    {<<"key">>, <<"a">>},
                    {<<"value">>, <<"1-23202479633c2b380f79507a776743d5">>},
                    {<<"doc">>,
                        {[
                            {<<"_id">>, <<"a">>},
                            {<<"_rev">>, <<"1-23202479633c2b380f79507a776743d5">>},
                            {<<"a">>, 1},
                            {<<"_access">>, [<<"x">>]}
                        ]}}
                ]},
                {[
                    {<<"id">>, <<"b">>},
                    {<<"key">>, <<"b">>},
                    {<<"value">>, <<"1-d33fb05384fa65a8081da2046595de0f">>},
                    {<<"doc">>,
                        {[
                            {<<"_id">>, <<"b">>},
                            {<<"_rev">>, <<"1-d33fb05384fa65a8081da2046595de0f">>},
                            {<<"b">>, 2},
                            {<<"_access">>, [<<"x">>]}
                        ]}}
                ]}
            ],
            Rows
        ),
        ?assertEqual(2, length(Rows)),
        ?assertEqual(4, proplists:get_value(<<"total_rows">>, Json)),

        {ok, 200, _, Body1} = test_request:get(
            Url ++ "/db/_all_docs?include_docs=true",
            ?USERY_REQ_HEADERS
        ),
        {Json1} = jiffy:decode(Body1),
        ?assertEqual(
            [
                {<<"total_rows">>, 4},
                {<<"offset">>, 2},
                {<<"rows">>, [
                    {[
                        {<<"id">>, <<"c">>},
                        {<<"key">>, <<"c">>},
                        {<<"value">>, <<"1-92aef5b0e4a3f4db0aba1320869bc95d">>},
                        {<<"doc">>,
                            {[
                                {<<"_id">>, <<"c">>},
                                {<<"_rev">>, <<"1-92aef5b0e4a3f4db0aba1320869bc95d">>},
                                {<<"c">>, 3},
                                {<<"_access">>, [<<"y">>]}
                            ]}}
                    ]},
                    {[
                        {<<"id">>, <<"d">>},
                        {<<"key">>, <<"d">>},
                        {<<"value">>, <<"1-ae984f6550038b1ed1565ac4b6cd8c5d">>},
                        {<<"doc">>,
                            {[
                                {<<"_id">>, <<"d">>},
                                {<<"_rev">>, <<"1-ae984f6550038b1ed1565ac4b6cd8c5d">>},
                                {<<"d">>, 4},
                                {<<"_access">>, [<<"y">>]}
                            ]}}
                    ]}
                ]}
            ],
            Json1
        )
    end).

% _changes

should_let_admin_fetch_changes(_PortType, Url) ->
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/a",
        ?ADMIN_REQ_HEADERS,
        "{\"a\":1,\"_access\":[\"x\"]}"
    ),
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/b",
        ?ADMIN_REQ_HEADERS,
        "{\"b\":2,\"_access\":[\"x\"]}"
    ),
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/c",
        ?ADMIN_REQ_HEADERS,
        "{\"c\":3,\"_access\":[\"y\"]}"
    ),
    {ok, 201, _, _} = test_request:put(
        Url ++ "/db/d",
        ?ADMIN_REQ_HEADERS,
        "{\"d\":4,\"_access\":[\"y\"]}"
    ),
    {ok, 200, _, Body} = test_request:get(
        Url ++ "/db/_changes",
        ?ADMIN_REQ_HEADERS
    ),
    {Json} = jiffy:decode(Body),
    AmountOfDocs = length(proplists:get_value(<<"results">>, Json)),
    ?_assertEqual(4, AmountOfDocs).

should_let_user_fetch_their_own_changes(_PortType, Url) ->
    ?_test(begin
        {ok, 201, _, _} = test_request:put(
            Url ++ "/db/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, 201, _, _} = test_request:put(
            Url ++ "/db/b",
            ?ADMIN_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, 201, _, _} = test_request:put(
            Url ++ "/db/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"y\"]}"
        ),
        {ok, 201, _, _} = test_request:put(
            Url ++ "/db/d",
            ?ADMIN_REQ_HEADERS,
            "{\"d\":4,\"_access\":[\"y\"]}"
        ),
        {ok, 200, _, Body} = test_request:get(
            Url ++ "/db/_changes",
            ?USERX_REQ_HEADERS
        ),
        {Json} = jiffy:decode(Body),
        ?assertMatch(
            [
                {<<"results">>, [
                    {[
                        {<<"seq">>, <<"2-", _/binary>>},
                        {<<"id">>, <<"a">>},
                        {<<"changes">>, [{[{<<"rev">>, <<"1-23202479633c2b380f79507a776743d5">>}]}]}
                    ]},
                    {[
                        {<<"seq">>, <<"3-", _/binary>>},
                        {<<"id">>, <<"b">>},
                        {<<"changes">>, [{[{<<"rev">>, <<"1-d33fb05384fa65a8081da2046595de0f">>}]}]}
                    ]}
                ]},
                {<<"last_seq">>, <<"3-", _/binary>>},
                {<<"pending">>, 2}
            ],
            Json
        ),
        AmountOfDocs = length(proplists:get_value(<<"results">>, Json)),
        ?assertEqual(2, AmountOfDocs)
    end).

% views

should_not_allow_admin_access_ddoc_view_request(_PortType, Url) ->
    DDoc = "{\"a\":1,\"_access\":[\"x\"],\"views\":{\"foo\":{\"map\":\"function() {}\"}}}",
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/_design/a",
        ?ADMIN_REQ_HEADERS,
        DDoc
    ),
    ?assertEqual(201, Code),
    {ok, Code1, _, _} = test_request:get(
        Url ++ "/db/_design/a/_view/foo",
        ?ADMIN_REQ_HEADERS
    ),
    ?_assertEqual(404, Code1).

should_not_allow_user_access_ddoc_view_request(_PortType, Url) ->
    DDoc = "{\"a\":1,\"_access\":[\"x\"],\"views\":{\"foo\":{\"map\":\"function() {}\"}}}",
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/_design/a",
        ?ADMIN_REQ_HEADERS,
        DDoc
    ),
    ?assertEqual(201, Code),
    {ok, Code1, _, _} = test_request:get(
        Url ++ "/db/_design/a/_view/foo",
        ?USERX_REQ_HEADERS
    ),
    ?_assertEqual(404, Code1).

should_allow_admin_users_access_ddoc_view_request(_PortType, Url) ->
    DDoc = "{\"a\":1,\"_access\":[\"_users\"],\"views\":{\"foo\":{\"map\":\"function() {}\"}}}",
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/_design/a",
        ?ADMIN_REQ_HEADERS,
        DDoc
    ),
    ?assertEqual(201, Code),
    {ok, Code1, _, _} = test_request:get(
        Url ++ "/db/_design/a/_view/foo",
        ?ADMIN_REQ_HEADERS
    ),
    ?_assertEqual(200, Code1).

should_allow_user_users_access_ddoc_view_request(_PortType, Url) ->
    DDoc = "{\"a\":1,\"_access\":[\"_users\"],\"views\":{\"foo\":{\"map\":\"function() {}\"}}}",
    {ok, Code, _, _} = test_request:put(
        Url ++ "/db/_design/a",
        ?ADMIN_REQ_HEADERS,
        DDoc
    ),
    ?assertEqual(201, Code),
    {ok, Code1, _, _} = test_request:get(
        Url ++ "/db/_design/a/_view/foo",
        ?USERX_REQ_HEADERS
    ),
    ?_assertEqual(200, Code1).

% replication

should_allow_admin_to_replicate_from_access_to_access(_PortType, Url) ->
    ?_test(begin
        % create target db
        {ok, 201, _, _} = test_request:put(
            url() ++ "/db2?q=1&n=1&access=true",
            ?ADMIN_REQ_HEADERS,
            ""
        ),
        % set target db security
        {ok, _, _, _} = test_request:put(
            url() ++ "/db2/_security",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(?SECURITY_OBJECT)
        ),

        % create source docs
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/b",
            ?ADMIN_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"x\"]}"
        ),

        % replicate
        AdminUrl = string:replace(Url, "http://", "http://a:a@"),
        EJRequestBody =
            {[
                {<<"source">>, list_to_binary(AdminUrl ++ "/db")},
                {<<"target">>, list_to_binary(AdminUrl ++ "/db2")}
            ]},
        {ok, ResponseCode, _, ResponseBody} = test_request:post(
            Url ++ "/_replicate",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(EJRequestBody)
        ),

        % assert replication status
        {EJResponseBody} = jiffy:decode(ResponseBody),
        ?assertEqual(ResponseCode, 200),
        ?assertEqual(true, couch_util:get_value(<<"ok">>, EJResponseBody)),
        [{History}] = couch_util:get_value(<<"history">>, EJResponseBody),

        MissingChecked = couch_util:get_value(<<"missing_checked">>, History),
        MissingFound = couch_util:get_value(<<"missing_found">>, History),
        DocsReard = couch_util:get_value(<<"docs_read">>, History),
        DocsWritten = couch_util:get_value(<<"docs_written">>, History),
        DocWriteFailures = couch_util:get_value(<<"doc_write_failures">>, History),

        ?assertEqual(3, MissingChecked),
        ?assertEqual(3, MissingFound),
        ?assertEqual(3, DocsReard),
        ?assertEqual(3, DocsWritten),
        ?assertEqual(0, DocWriteFailures),

        % assert docs in target db
        {ok, 200, _, ADBody} = test_request:get(
            Url ++ "/db2/_all_docs?include_docs=true",
            ?ADMIN_REQ_HEADERS
        ),
        {Json} = jiffy:decode(ADBody),
        ?assertEqual(3, proplists:get_value(<<"total_rows">>, Json))
    end).

should_allow_admin_to_replicate_from_no_access_to_access(_PortType, Url) ->
    ?_test(begin
        % create target db
        {ok, 201, _, _} = test_request:put(
            url() ++ "/db2?q=1&n=1",
            ?ADMIN_REQ_HEADERS,
            ""
        ),
        % set target db security
        {ok, _, _, _} = test_request:put(
            url() ++ "/db2/_security",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(?SECURITY_OBJECT)
        ),

        % create source docs
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/b",
            ?ADMIN_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"x\"]}"
        ),

        % replicate
        AdminUrl = string:replace(Url, "http://", "http://a:a@"),
        EJRequestBody =
            {[
                {<<"source">>, list_to_binary(AdminUrl ++ "/db2")},
                {<<"target">>, list_to_binary(AdminUrl ++ "/db")}
            ]},
        {ok, ResponseCode, _, ResponseBody} = test_request:post(
            Url ++ "/_replicate",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(EJRequestBody)
        ),

        % assert replication status
        {EJResponseBody} = jiffy:decode(ResponseBody),
        ?assertEqual(ResponseCode, 200),
        ?assertEqual(true, couch_util:get_value(<<"ok">>, EJResponseBody)),
        [{History}] = couch_util:get_value(<<"history">>, EJResponseBody),

        MissingChecked = couch_util:get_value(<<"missing_checked">>, History),
        MissingFound = couch_util:get_value(<<"missing_found">>, History),
        DocsReard = couch_util:get_value(<<"docs_read">>, History),
        DocsWritten = couch_util:get_value(<<"docs_written">>, History),
        DocWriteFailures = couch_util:get_value(<<"doc_write_failures">>, History),

        ?assertEqual(3, MissingChecked),
        ?assertEqual(3, MissingFound),
        ?assertEqual(3, DocsReard),
        ?assertEqual(3, DocsWritten),
        ?assertEqual(0, DocWriteFailures),

        % assert docs in target db
        {ok, 200, _, ADBody} = test_request:get(
            Url ++ "/db/_all_docs?include_docs=true",
            ?ADMIN_REQ_HEADERS
        ),
        {Json} = jiffy:decode(ADBody),
        ?assertEqual(3, proplists:get_value(<<"total_rows">>, Json))
    end).

should_allow_admin_to_replicate_from_access_to_no_access(_PortType, Url) ->
    ?_test(begin
        % create target db
        {ok, 201, _, _} = test_request:put(
            url() ++ "/db2?q=1&n=1",
            ?ADMIN_REQ_HEADERS,
            ""
        ),
        % set target db security
        {ok, _, _, _} = test_request:put(
            url() ++ "/db2/_security",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(?SECURITY_OBJECT)
        ),

        % create source docs
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/b",
            ?ADMIN_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"x\"]}"
        ),

        % replicate
        AdminUrl = string:replace(Url, "http://", "http://a:a@"),
        EJRequestBody =
            {[
                {<<"source">>, list_to_binary(AdminUrl ++ "/db")},
                {<<"target">>, list_to_binary(AdminUrl ++ "/db2")}
            ]},
        {ok, ResponseCode, _, ResponseBody} = test_request:post(
            Url ++ "/_replicate",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(EJRequestBody)
        ),

        % assert replication status
        {EJResponseBody} = jiffy:decode(ResponseBody),
        ?assertEqual(ResponseCode, 200),
        ?assertEqual(true, couch_util:get_value(<<"ok">>, EJResponseBody)),
        [{History}] = couch_util:get_value(<<"history">>, EJResponseBody),

        MissingChecked = couch_util:get_value(<<"missing_checked">>, History),
        MissingFound = couch_util:get_value(<<"missing_found">>, History),
        DocsReard = couch_util:get_value(<<"docs_read">>, History),
        DocsWritten = couch_util:get_value(<<"docs_written">>, History),
        DocWriteFailures = couch_util:get_value(<<"doc_write_failures">>, History),

        ?assertEqual(3, MissingChecked),
        ?assertEqual(3, MissingFound),
        ?assertEqual(3, DocsReard),
        ?assertEqual(3, DocsWritten),
        ?assertEqual(0, DocWriteFailures),

        % assert docs in target db
        {ok, 200, _, ADBody} = test_request:get(
            Url ++ "/db2/_all_docs?include_docs=true",
            ?ADMIN_REQ_HEADERS
        ),
        {Json} = jiffy:decode(ADBody),
        ?assertEqual(3, proplists:get_value(<<"total_rows">>, Json))
    end).

should_allow_admin_to_replicate_from_no_access_to_no_access(_PortType, Url) ->
    ?_test(begin
        % create source and target dbs
        {ok, 201, _, _} = test_request:put(
            url() ++ "/db2?q=1&n=1",
            ?ADMIN_REQ_HEADERS,
            ""
        ),
        % set target db security
        {ok, _, _, _} = test_request:put(
            url() ++ "/db2/_security",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(?SECURITY_OBJECT)
        ),

        {ok, 201, _, _} = test_request:put(
            url() ++ "/db3?q=1&n=1",
            ?ADMIN_REQ_HEADERS,
            ""
        ),
        % set target db security
        {ok, _, _, _} = test_request:put(
            url() ++ "/db3/_security",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(?SECURITY_OBJECT)
        ),

        % create source docs
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/b",
            ?ADMIN_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"x\"]}"
        ),

        % replicate
        AdminUrl = string:replace(Url, "http://", "http://a:a@"),
        EJRequestBody =
            {[
                {<<"source">>, list_to_binary(AdminUrl ++ "/db2")},
                {<<"target">>, list_to_binary(AdminUrl ++ "/db3")}
            ]},
        {ok, ResponseCode, _, ResponseBody} = test_request:post(
            Url ++ "/_replicate",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(EJRequestBody)
        ),

        % assert replication status
        {EJResponseBody} = jiffy:decode(ResponseBody),
        ?assertEqual(ResponseCode, 200),
        ?assertEqual(true, couch_util:get_value(<<"ok">>, EJResponseBody)),
        [{History}] = couch_util:get_value(<<"history">>, EJResponseBody),

        MissingChecked = couch_util:get_value(<<"missing_checked">>, History),
        MissingFound = couch_util:get_value(<<"missing_found">>, History),
        DocsReard = couch_util:get_value(<<"docs_read">>, History),
        DocsWritten = couch_util:get_value(<<"docs_written">>, History),
        DocWriteFailures = couch_util:get_value(<<"doc_write_failures">>, History),

        ?assertEqual(3, MissingChecked),
        ?assertEqual(3, MissingFound),
        ?assertEqual(3, DocsReard),
        ?assertEqual(3, DocsWritten),
        ?assertEqual(0, DocWriteFailures),

        % assert docs in target db
        {ok, 200, _, ADBody} = test_request:get(
            Url ++ "/db3/_all_docs?include_docs=true",
            ?ADMIN_REQ_HEADERS
        ),
        {Json} = jiffy:decode(ADBody),
        ?assertEqual(3, proplists:get_value(<<"total_rows">>, Json))
    end).

should_allow_user_to_replicate_from_access_to_access(_PortType, Url) ->
    ?_test(begin
        % create source and target dbs
        {ok, 201, _, _} = test_request:put(
            url() ++ "/db2?q=1&n=1&access=true",
            ?ADMIN_REQ_HEADERS,
            ""
        ),
        % set target db security
        {ok, _, _, _} = test_request:put(
            url() ++ "/db2/_security",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(?SECURITY_OBJECT)
        ),

        % create source docs
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/b",
            ?ADMIN_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"y\"]}"
        ),

        % replicate
        UserXUrl = string:replace(Url, "http://", "http://x:x@"),
        EJRequestBody =
            {[
                {<<"source">>, list_to_binary(UserXUrl ++ "/db")},
                {<<"target">>, list_to_binary(UserXUrl ++ "/db2")}
            ]},
        {ok, ResponseCode, _, ResponseBody} = test_request:post(
            Url ++ "/_replicate",
            ?USERX_REQ_HEADERS,
            jiffy:encode(EJRequestBody)
        ),
        % ?debugFmt("~nResponseBody: ~p~n", [ResponseBody]),

        % assert replication status
        {EJResponseBody} = jiffy:decode(ResponseBody),
        ?assertEqual(ResponseCode, 200),
        ?assertEqual(true, couch_util:get_value(<<"ok">>, EJResponseBody)),

        [{History}] = couch_util:get_value(<<"history">>, EJResponseBody),

        MissingChecked = couch_util:get_value(<<"missing_checked">>, History),
        MissingFound = couch_util:get_value(<<"missing_found">>, History),
        DocsReard = couch_util:get_value(<<"docs_read">>, History),
        DocsWritten = couch_util:get_value(<<"docs_written">>, History),
        DocWriteFailures = couch_util:get_value(<<"doc_write_failures">>, History),

        ?assertEqual(2, MissingChecked),
        ?assertEqual(2, MissingFound),
        ?assertEqual(2, DocsReard),
        ?assertEqual(2, DocsWritten),
        ?assertEqual(0, DocWriteFailures),

        % assert access in local doc
        ReplicationId = couch_util:get_value(<<"replication_id">>, EJResponseBody),
        {ok, 200, _, CheckPoint} = test_request:get(
            Url ++ "/db/_local/" ++ ReplicationId,
            ?USERX_REQ_HEADERS
        ),
        {EJCheckPoint} = jiffy:decode(CheckPoint),
        Access = couch_util:get_value(<<"_access">>, EJCheckPoint),
        ?assertEqual([<<"x">>], Access),

        % make sure others can’t read our local docs
        {ok, 403, _, _} = test_request:get(
            Url ++ "/db/_local/" ++ ReplicationId,
            ?USERY_REQ_HEADERS
        ),

        % assert docs in target db
        {ok, 200, _, ADBody} = test_request:get(
            Url ++ "/db2/_all_docs?include_docs=true",
            ?ADMIN_REQ_HEADERS
        ),
        {Json} = jiffy:decode(ADBody),
        ?assertEqual(2, proplists:get_value(<<"total_rows">>, Json))
    end).

should_allow_user_to_replicate_from_access_to_no_access(_PortType, Url) ->
    ?_test(begin
        % create source and target dbs
        {ok, 201, _, _} = test_request:put(
            url() ++ "/db2?q=1&n=1",
            ?ADMIN_REQ_HEADERS,
            ""
        ),
        % set target db security
        {ok, _, _, _} = test_request:put(
            url() ++ "/db2/_security",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(?SECURITY_OBJECT)
        ),

        % create source docs
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/b",
            ?ADMIN_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"y\"]}"
        ),

        % replicate
        UserXUrl = string:replace(Url, "http://", "http://x:x@"),
        EJRequestBody =
            {[
                {<<"source">>, list_to_binary(UserXUrl ++ "/db")},
                {<<"target">>, list_to_binary(UserXUrl ++ "/db2")}
            ]},
        {ok, ResponseCode, _, ResponseBody} = test_request:post(
            Url ++ "/_replicate",
            ?USERX_REQ_HEADERS,
            jiffy:encode(EJRequestBody)
        ),

        % assert replication status
        {EJResponseBody} = jiffy:decode(ResponseBody),
        ?assertEqual(ResponseCode, 200),
        ?assertEqual(true, couch_util:get_value(<<"ok">>, EJResponseBody)),
        [{History}] = couch_util:get_value(<<"history">>, EJResponseBody),

        MissingChecked = couch_util:get_value(<<"missing_checked">>, History),
        MissingFound = couch_util:get_value(<<"missing_found">>, History),
        DocsReard = couch_util:get_value(<<"docs_read">>, History),
        DocsWritten = couch_util:get_value(<<"docs_written">>, History),
        DocWriteFailures = couch_util:get_value(<<"doc_write_failures">>, History),

        ?assertEqual(2, MissingChecked),
        ?assertEqual(2, MissingFound),
        ?assertEqual(2, DocsReard),
        ?assertEqual(2, DocsWritten),
        ?assertEqual(0, DocWriteFailures),

        % assert docs in target db
        {ok, 200, _, ADBody} = test_request:get(
            Url ++ "/db2/_all_docs?include_docs=true",
            ?ADMIN_REQ_HEADERS
        ),
        {Json} = jiffy:decode(ADBody),
        ?assertEqual(2, proplists:get_value(<<"total_rows">>, Json))
    end).

should_allow_user_to_replicate_from_no_access_to_access(_PortType, Url) ->
    ?_test(begin
        % create source and target dbs
        {ok, 201, _, _} = test_request:put(
            url() ++ "/db2?q=1&n=1",
            ?ADMIN_REQ_HEADERS,
            ""
        ),
        % set target db security
        {ok, _, _, _} = test_request:put(
            url() ++ "/db2/_security",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(?SECURITY_OBJECT)
        ),

        % leave for easier debugging
        % VduFun = <<"function(newdoc, olddoc, userctx) {if(newdoc._id == \"b\") throw({'forbidden':'fail'})}">>,
        % DDoc = {[
        %    {<<"_id">>, <<"_design/vdu">>},
        %    {<<"validate_doc_update">>, VduFun}
        % ]},
        % {ok, _, _, _} = test_request:put(Url ++ "/db/_design/vdu",
        %     ?ADMIN_REQ_HEADERS, jiffy:encode(DDoc)),
        % create source docs
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/b",
            ?ADMIN_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"y\"]}"
        ),

        % replicate
        UserXUrl = string:replace(Url, "http://", "http://x:x@"),
        EJRequestBody =
            {[
                {<<"source">>, list_to_binary(UserXUrl ++ "/db2")},
                {<<"target">>, list_to_binary(UserXUrl ++ "/db")}
            ]},
        {ok, ResponseCode, _, ResponseBody} = test_request:post(
            Url ++ "/_replicate",
            ?USERX_REQ_HEADERS,
            jiffy:encode(EJRequestBody)
        ),

        % assert replication status
        {EJResponseBody} = jiffy:decode(ResponseBody),
        ?assertEqual(ResponseCode, 200),
        ?assertEqual(true, couch_util:get_value(<<"ok">>, EJResponseBody)),
        [{History}] = couch_util:get_value(<<"history">>, EJResponseBody),

        MissingChecked = couch_util:get_value(<<"missing_checked">>, History),
        MissingFound = couch_util:get_value(<<"missing_found">>, History),
        DocsRead = couch_util:get_value(<<"docs_read">>, History),
        DocsWritten = couch_util:get_value(<<"docs_written">>, History),
        DocWriteFailures = couch_util:get_value(<<"doc_write_failures">>, History),
        % ?debugFmt("~n History: ~p ~n", [History]),
        ?assertEqual(3, MissingChecked),
        ?assertEqual(3, MissingFound),
        ?assertEqual(3, DocsRead),
        ?assertEqual(2, DocsWritten),
        ?assertEqual(1, DocWriteFailures),

        % assert docs in target db
        {ok, 200, _, ADBody} = test_request:get(
            Url ++ "/db/_all_docs?include_docs=true",
            ?ADMIN_REQ_HEADERS
        ),
        {Json} = jiffy:decode(ADBody),
        ?assertEqual(2, proplists:get_value(<<"total_rows">>, Json))
    end).

should_allow_user_to_replicate_from_no_access_to_no_access(_PortType, Url) ->
    ?_test(begin
        % create source and target dbs
        {ok, 201, _, _} = test_request:put(
            url() ++ "/db2?q=1&n=1",
            ?ADMIN_REQ_HEADERS,
            ""
        ),
        % set target db security
        {ok, _, _, _} = test_request:put(
            url() ++ "/db2/_security",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(?SECURITY_OBJECT)
        ),

        {ok, 201, _, _} = test_request:put(
            url() ++ "/db3?q=1&n=1",
            ?ADMIN_REQ_HEADERS,
            ""
        ),
        % set target db security
        {ok, _, _, _} = test_request:put(
            url() ++ "/db3/_security",
            ?ADMIN_REQ_HEADERS,
            jiffy:encode(?SECURITY_OBJECT)
        ),
        % create source docs
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/b",
            ?ADMIN_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db2/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"y\"]}"
        ),

        % replicate
        UserXUrl = string:replace(Url, "http://", "http://x:x@"),
        EJRequestBody =
            {[
                {<<"source">>, list_to_binary(UserXUrl ++ "/db2")},
                {<<"target">>, list_to_binary(UserXUrl ++ "/db3")}
            ]},
        {ok, ResponseCode, _, ResponseBody} = test_request:post(
            Url ++ "/_replicate",
            ?USERX_REQ_HEADERS,
            jiffy:encode(EJRequestBody)
        ),

        % assert replication status
        {EJResponseBody} = jiffy:decode(ResponseBody),
        ?assertEqual(ResponseCode, 200),
        ?assertEqual(true, couch_util:get_value(<<"ok">>, EJResponseBody)),
        [{History}] = couch_util:get_value(<<"history">>, EJResponseBody),

        MissingChecked = couch_util:get_value(<<"missing_checked">>, History),
        MissingFound = couch_util:get_value(<<"missing_found">>, History),
        DocsReard = couch_util:get_value(<<"docs_read">>, History),
        DocsWritten = couch_util:get_value(<<"docs_written">>, History),
        DocWriteFailures = couch_util:get_value(<<"doc_write_failures">>, History),

        ?assertEqual(3, MissingChecked),
        ?assertEqual(3, MissingFound),
        ?assertEqual(3, DocsReard),
        ?assertEqual(3, DocsWritten),
        ?assertEqual(0, DocWriteFailures),

        % assert docs in target db
        {ok, 200, _, ADBody} = test_request:get(
            Url ++ "/db3/_all_docs?include_docs=true",
            ?ADMIN_REQ_HEADERS
        ),
        {Json} = jiffy:decode(ADBody),
        ?assertEqual(3, proplists:get_value(<<"total_rows">>, Json))
    end).

% revs_diff
should_not_allow_user_to_revs_diff_other_docs(_PortType, Url) ->
    ?_test(begin
        % create test docs
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/a",
            ?ADMIN_REQ_HEADERS,
            "{\"a\":1,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, _} = test_request:put(
            Url ++ "/db/b",
            ?ADMIN_REQ_HEADERS,
            "{\"b\":2,\"_access\":[\"x\"]}"
        ),
        {ok, _, _, V} = test_request:put(
            Url ++ "/db/c",
            ?ADMIN_REQ_HEADERS,
            "{\"c\":3,\"_access\":[\"y\"]}"
        ),

        % nothing missing
        RevsDiff =
            {[
                {<<"a">>, [
                    <<"1-23202479633c2b380f79507a776743d5">>
                ]}
            ]},
        {ok, GoodCode, _, GoodBody} = test_request:post(
            Url ++ "/db/_revs_diff",
            ?USERX_REQ_HEADERS,
            jiffy:encode(RevsDiff)
        ),
        EJGoodBody = jiffy:decode(GoodBody),
        ?assertEqual(200, GoodCode),
        ?assertEqual({[]}, EJGoodBody),

        % something missing
        MissingRevsDiff =
            {[
                {<<"a">>, [
                    <<"1-missing">>
                ]}
            ]},
        {ok, MissingCode, _, MissingBody} = test_request:post(
            Url ++ "/db/_revs_diff",
            ?USERX_REQ_HEADERS,
            jiffy:encode(MissingRevsDiff)
        ),
        EJMissingBody = jiffy:decode(MissingBody),
        ?assertEqual(200, MissingCode),
        MissingExpect =
            {[
                {<<"a">>,
                    {[
                        {<<"missing">>, [<<"1-missing">>]}
                    ]}}
            ]},
        ?assertEqual(MissingExpect, EJMissingBody),

        % other doc
        OtherRevsDiff =
            {[
                {<<"c">>, [
                    <<"1-92aef5b0e4a3f4db0aba1320869bc95d">>
                ]}
            ]},
        {ok, OtherCode, _, OtherBody} = test_request:post(
            Url ++ "/db/_revs_diff",
            ?USERX_REQ_HEADERS,
            jiffy:encode(OtherRevsDiff)
        ),
        EJOtherBody = jiffy:decode(OtherBody),
        ?assertEqual(200, OtherCode),
        ?assertEqual({[]}, EJOtherBody)
    end).
%% ------------------------------------------------------------------
%% Internal Function Definitions
%% ------------------------------------------------------------------

port() ->
    integer_to_list(mochiweb_socket_server:get(chttpd, port)).

% Potential future feature:%
% should_let_user_fetch_their_own_all_docs_plus_users_ddocs(_PortType, Url) ->
%     {ok, 201, _, _} = test_request:put(Url ++ "/db/a",
%         ?ADMIN_REQ_HEADERS, "{\"a\":1,\"_access\":[\"x\"]}"),
%     {ok, 201, _, _} = test_request:put(Url ++ "/db/_design/foo",
%         ?ADMIN_REQ_HEADERS, "{\"a\":1,\"_access\":[\"_users\"]}"),
%     {ok, 201, _, _} = test_request:put(Url ++ "/db/_design/bar",
%         ?ADMIN_REQ_HEADERS, "{\"a\":1,\"_access\":[\"houdini\"]}"),
%     {ok, 201, _, _} = test_request:put(Url ++ "/db/b",
%         ?USERX_REQ_HEADERS, "{\"b\":2,\"_access\":[\"x\"]}"),
%
%     % % TODO: add allowing non-admin users adding non-admin ddocs
%     {ok, 201, _, _} = test_request:put(Url ++ "/db/_design/x",
%         ?ADMIN_REQ_HEADERS, "{\"b\":2,\"_access\":[\"x\"]}"),
%
%     {ok, 201, _, _} = test_request:put(Url ++ "/db/c",
%         ?ADMIN_REQ_HEADERS, "{\"c\":3,\"_access\":[\"y\"]}"),
%     {ok, 201, _, _} = test_request:put(Url ++ "/db/d",
%         ?USERY_REQ_HEADERS, "{\"d\":4,\"_access\":[\"y\"]}"),
%     {ok, 200, _, Body} = test_request:get(Url ++ "/db/_all_docs?include_docs=true",
%         ?USERX_REQ_HEADERS),
%     {Json} = jiffy:decode(Body),
%     ?_assertEqual(3, length(proplists:get_value(<<"rows">>, Json))).
%     ?debugFmt("~nHSOIN: ~p~n", [Json]),