% 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(fabric2_doc_crud_tests).

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

doc_crud_test_() ->
    {
        "Test document CRUD operations",
        {
            setup,
            fun setup/0,
            fun cleanup/1,
            with([
                ?TDEF(open_missing_doc),
                ?TDEF(create_new_doc),
                ?TDEF(create_ddoc_basic),
                ?TDEF(create_ddoc_requires_admin),
                ?TDEF(create_ddoc_requires_validation),
                ?TDEF(create_ddoc_requires_compilation),
                ?TDEF(can_create_a_partitioned_ddoc),
                ?TDEF(update_doc_basic),
                ?TDEF(update_ddoc_basic),
                ?TDEF(update_doc_replicated),
                ?TDEF(update_doc_replicated_add_conflict),
                ?TDEF(update_doc_replicated_changes_winner),
                ?TDEF(update_doc_replicated_extension),
                ?TDEF(update_doc_replicate_existing_rev),
                ?TDEF(update_winning_conflict_branch),
                ?TDEF(update_non_winning_conflict_branch),
                ?TDEF(delete_doc_basic),
                ?TDEF(delete_changes_winner),
                ?TDEF(recreate_doc_basic),
                ?TDEF(conflict_on_create_new_with_rev),
                ?TDEF(conflict_on_update_with_no_rev),
                ?TDEF(allow_create_new_as_deleted),
                ?TDEF(conflict_on_recreate_as_deleted),
                ?TDEF(conflict_on_extend_deleted),
                ?TDEF(open_doc_revs_basic),
                ?TDEF(open_doc_revs_all),
                ?TDEF(open_doc_revs_latest),
                ?TDEF(get_missing_revs_basic),
                ?TDEF(get_missing_revs_on_missing_doc),
                ?TDEF(open_missing_local_doc),
                ?TDEF(create_local_doc_basic),
                ?TDEF(update_local_doc_basic),
                ?TDEF(delete_local_doc_basic),
                ?TDEF(recreate_local_doc),
                ?TDEF(create_local_doc_bad_rev),
                ?TDEF(create_local_doc_random_rev),
                ?TDEF(create_a_large_local_doc),
                ?TDEF(create_2_large_local_docs),
                ?TDEF(local_doc_with_previous_encoding),
                ?TDEF(before_doc_update_skips_local_docs),
                ?TDEF(open_doc_opts)
            ])
        }
    }.

setup() ->
    Ctx = test_util:start_couch([fabric, couch_js]),
    {ok, Db} = fabric2_db:create(?tempdb(), [{user_ctx, ?ADMIN_USER}]),
    {Db, Ctx}.

cleanup({Db, Ctx}) ->
    ok = fabric2_db:delete(fabric2_db:name(Db), []),
    test_util:stop_couch(Ctx).

open_missing_doc({Db, _}) ->
    ?assertEqual({not_found, missing}, fabric2_db:open_doc(Db, <<"foo">>)).

create_new_doc({Db, _}) ->
    Doc = #doc{
        id = fabric2_util:uuid(),
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {RevPos, Rev}} = fabric2_db:update_doc(Db, Doc),
    NewDoc = Doc#doc{revs = {RevPos, [Rev]}},
    ?assertEqual({ok, NewDoc}, fabric2_db:open_doc(Db, Doc#doc.id)).

create_ddoc_basic({Db, _}) ->
    UUID = fabric2_util:uuid(),
    DDocId = <<"_design/", UUID/binary>>,
    Doc = #doc{
        id = DDocId,
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {RevPos, Rev}} = fabric2_db:update_doc(Db, Doc),
    NewDoc = Doc#doc{revs = {RevPos, [Rev]}},
    ?assertEqual({ok, NewDoc}, fabric2_db:open_doc(Db, Doc#doc.id)).

can_create_a_partitioned_ddoc({Db, _}) ->
    UUID = fabric2_util:uuid(),
    DDocId = <<"_design/", UUID/binary>>,
    Doc = #doc{
        id = DDocId,
        body =
            {[
                {<<"options">>, {[{<<"partitioned">>, true}]}},
                {<<"views">>,
                    {[
                        {<<"foo">>,
                            {[
                                {<<"map">>, <<"function(doc) {}">>}
                            ]}}
                    ]}}
            ]}
    },
    ?assertMatch({ok, {_, _}}, fabric2_db:update_doc(Db, Doc)).

create_ddoc_requires_admin({Db, _}) ->
    Db2 = fabric2_db:set_user_ctx(Db, #user_ctx{}),
    UUID = fabric2_util:uuid(),
    DDocId = <<"_design/", UUID/binary>>,
    Doc = #doc{
        id = DDocId,
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    ?assertThrow({unauthorized, _}, fabric2_db:update_doc(Db2, Doc)).

create_ddoc_requires_validation({Db, _}) ->
    UUID = fabric2_util:uuid(),
    DDocId = <<"_design/", UUID/binary>>,
    Doc = #doc{
        id = DDocId,
        body =
            {[
                {<<"views">>,
                    {[
                        {<<"foo">>,
                            {[
                                {<<"map">>, <<"function(doc) {}">>},
                                {<<"reduce">>, <<"_not_a_builtin_reduce">>}
                            ]}}
                    ]}}
            ]}
    },
    ?assertThrow(
        {bad_request, invalid_design_doc, _},
        fabric2_db:update_doc(Db, Doc)
    ).

create_ddoc_requires_compilation({Db, _}) ->
    UUID = fabric2_util:uuid(),
    DDocId = <<"_design/", UUID/binary>>,
    Doc = #doc{
        id = DDocId,
        body =
            {[
                {<<"language">>, <<"javascript">>},
                {<<"views">>,
                    {[
                        {<<"foo">>,
                            {[
                                {<<"map">>, <<"Hopefully this is invalid JavaScript">>}
                            ]}}
                    ]}}
            ]}
    },
    ?assertThrow(
        {bad_request, compilation_error, _},
        fabric2_db:update_doc(Db, Doc)
    ).

update_doc_basic({Db, _}) ->
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        body = {[{<<"state">>, 1}]}
    },
    {ok, {Pos1, Rev1}} = fabric2_db:update_doc(Db, Doc1),
    Doc2 = Doc1#doc{
        revs = {Pos1, [Rev1]},
        body = {[{<<"state">>, 2}]}
    },
    {ok, {Pos2, Rev2}} = fabric2_db:update_doc(Db, Doc2),
    Doc3 = Doc2#doc{
        revs = {Pos2, [Rev2, Rev1]}
    },
    ?assertEqual({ok, Doc3}, fabric2_db:open_doc(Db, Doc2#doc.id)).

update_ddoc_basic({Db, _}) ->
    UUID = fabric2_util:uuid(),
    DDocId = <<"_design/", UUID/binary>>,
    Doc1 = #doc{
        id = DDocId,
        body = {[{<<"state">>, 1}]}
    },
    {ok, {Pos1, Rev1}} = fabric2_db:update_doc(Db, Doc1),
    Doc2 = Doc1#doc{
        revs = {Pos1, [Rev1]},
        body = {[{<<"state">>, 2}]}
    },
    {ok, {Pos2, Rev2}} = fabric2_db:update_doc(Db, Doc2),
    Doc3 = Doc2#doc{
        revs = {Pos2, [Rev2, Rev1]}
    },
    ?assertEqual({ok, Doc3}, fabric2_db:open_doc(Db, Doc2#doc.id)).

update_doc_replicated({Db, _}) ->
    Doc = #doc{
        id = fabric2_util:uuid(),
        revs = {2, [fabric2_util:uuid(), fabric2_util:uuid()]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc, [replicated_changes]),
    ?assertEqual({ok, Doc}, fabric2_db:open_doc(Db, Doc#doc.id)).

update_doc_replicated_add_conflict({Db, _}) ->
    [Rev1, Rev2, Rev3] = lists:sort([
        fabric2_util:uuid(),
        fabric2_util:uuid(),
        fabric2_util:uuid()
    ]),
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        revs = {2, [Rev3, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    ?assertEqual({ok, Doc1}, fabric2_db:open_doc(Db, Doc1#doc.id)),
    Doc2 = Doc1#doc{
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"bar">>, <<"foo">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),
    ?assertEqual({ok, Doc1}, fabric2_db:open_doc(Db, Doc2#doc.id)).

update_doc_replicated_changes_winner({Db, _}) ->
    [Rev1, Rev2, Rev3] = lists:sort([
        fabric2_util:uuid(),
        fabric2_util:uuid(),
        fabric2_util:uuid()
    ]),
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    ?assertEqual({ok, Doc1}, fabric2_db:open_doc(Db, Doc1#doc.id)),
    Doc2 = Doc1#doc{
        revs = {2, [Rev3, Rev1]},
        body = {[{<<"bar">>, <<"foo">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),
    ?assertEqual({ok, Doc2}, fabric2_db:open_doc(Db, Doc2#doc.id)).

update_doc_replicated_extension({Db, _}) ->
    % No sort necessary and avoided on purpose to
    % demonstrate that this is not sort dependent
    Rev1 = fabric2_util:uuid(),
    Rev2 = fabric2_util:uuid(),
    Rev3 = fabric2_util:uuid(),
    Rev4 = fabric2_util:uuid(),
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    Doc2 = Doc1#doc{
        revs = {4, [Rev4, Rev3, Rev2]},
        body = {[{<<"bar">>, <<"foo">>}]}
    },
    {ok, {4, _}} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),
    {ok, Doc3} = fabric2_db:open_doc(Db, Doc2#doc.id),
    ?assertEqual({4, [Rev4, Rev3, Rev2, Rev1]}, Doc3#doc.revs),
    ?assertEqual(Doc2#doc{revs = undefined}, Doc3#doc{revs = undefined}).

update_doc_replicate_existing_rev({Db, _}) ->
    Rev1 = fabric2_util:uuid(),
    Rev2 = fabric2_util:uuid(),
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    {ok, []} = fabric2_db:update_docs(Db, [Doc1], [replicated_changes]),
    ?assertEqual({ok, Doc1}, fabric2_db:open_doc(Db, Doc1#doc.id)).

update_winning_conflict_branch({Db, _}) ->
    [Rev1, Rev2, Rev3] = lists:sort([
        fabric2_util:uuid(),
        fabric2_util:uuid(),
        fabric2_util:uuid()
    ]),
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        revs = {2, [Rev3, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    Doc2 = Doc1#doc{
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"bar">>, <<"foo">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),
    % Update the winning branch
    Doc3 = Doc1#doc{
        revs = {2, [Rev3, Rev1]},
        body = {[{<<"baz">>, 2}]}
    },
    {ok, {3, Rev4}} = fabric2_db:update_doc(Db, Doc3),
    {ok, Doc4} = fabric2_db:open_doc(Db, Doc3#doc.id),
    % Assert we've got the correct winner
    ?assertEqual({3, [Rev4, Rev3, Rev1]}, Doc4#doc.revs),
    ?assertEqual(Doc3#doc{revs = undefined}, Doc4#doc{revs = undefined}).

update_non_winning_conflict_branch({Db, _}) ->
    [Rev1, Rev2, Rev3] = lists:sort([
        fabric2_util:uuid(),
        fabric2_util:uuid(),
        fabric2_util:uuid()
    ]),
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        revs = {2, [Rev3, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    Doc2 = Doc1#doc{
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"bar">>, <<"foo">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),
    % Update the non winning branch
    Doc3 = Doc1#doc{
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"baz">>, 2}]}
    },
    {ok, {3, Rev4}} = fabric2_db:update_doc(Db, Doc3),
    {ok, Doc4} = fabric2_db:open_doc(Db, Doc3#doc.id),
    % Assert we've got the correct winner
    ?assertEqual({3, [Rev4, Rev2, Rev1]}, Doc4#doc.revs),
    ?assertEqual(Doc3#doc{revs = undefined}, Doc4#doc{revs = undefined}).

delete_doc_basic({Db, _}) ->
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        body = {[{<<"state">>, 1}]}
    },
    {ok, {Pos1, Rev1}} = fabric2_db:update_doc(Db, Doc1),
    Doc2 = Doc1#doc{
        revs = {Pos1, [Rev1]},
        deleted = true,
        body = {[{<<"state">>, 2}]}
    },
    {ok, {Pos2, Rev2}} = fabric2_db:update_doc(Db, Doc2),
    Doc3 = Doc2#doc{revs = {Pos2, [Rev2, Rev1]}},
    ?assertEqual({ok, Doc3}, fabric2_db:open_doc(Db, Doc2#doc.id, [deleted])).

delete_changes_winner({Db, _}) ->
    [Rev1, Rev2, Rev3] = lists:sort([
        fabric2_util:uuid(),
        fabric2_util:uuid(),
        fabric2_util:uuid()
    ]),
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        revs = {2, [Rev3, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    Doc2 = Doc1#doc{
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"bar">>, <<"foo">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),
    % Delete the winning branch
    Doc3 = Doc1#doc{
        revs = {2, [Rev3, Rev1]},
        deleted = true,
        body = {[]}
    },
    {ok, {3, _}} = fabric2_db:update_doc(Db, Doc3),
    ?assertEqual({ok, Doc2}, fabric2_db:open_doc(Db, Doc3#doc.id)).

recreate_doc_basic({Db, _}) ->
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        body = {[{<<"state">>, 1}]}
    },
    {ok, {1, Rev1}} = fabric2_db:update_doc(Db, Doc1),
    Doc2 = Doc1#doc{
        revs = {1, [Rev1]},
        deleted = true,
        body = {[{<<"state">>, 2}]}
    },
    {ok, {2, Rev2}} = fabric2_db:update_doc(Db, Doc2),
    Doc3 = Doc1#doc{
        revs = {0, []},
        deleted = false,
        body = {[{<<"state">>, 3}]}
    },
    {ok, {3, Rev3}} = fabric2_db:update_doc(Db, Doc3),
    {ok, Doc4} = fabric2_db:open_doc(Db, Doc3#doc.id),
    ?assertEqual({3, [Rev3, Rev2, Rev1]}, Doc4#doc.revs),
    ?assertEqual(Doc3#doc{revs = undefined}, Doc4#doc{revs = undefined}).

conflict_on_create_new_with_rev({Db, _}) ->
    Doc = #doc{
        id = fabric2_util:uuid(),
        revs = {1, [fabric2_util:uuid()]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    ?assertThrow(conflict, fabric2_db:update_doc(Db, Doc)).

conflict_on_update_with_no_rev({Db, _}) ->
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        body = {[{<<"state">>, 1}]}
    },
    {ok, _} = fabric2_db:update_doc(Db, Doc1),
    Doc2 = Doc1#doc{
        revs = {0, []},
        body = {[{<<"state">>, 2}]}
    },
    ?assertThrow(conflict, fabric2_db:update_doc(Db, Doc2)).

allow_create_new_as_deleted({Db, _}) ->
    Doc = #doc{
        id = fabric2_util:uuid(),
        deleted = true,
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {1, Rev}} = fabric2_db:update_doc(Db, Doc),
    ?assertEqual({not_found, deleted}, fabric2_db:open_doc(Db, Doc#doc.id)),
    Doc1 = Doc#doc{
        revs = {1, [Rev]}
    },
    ?assertEqual({ok, Doc1}, fabric2_db:open_doc(Db, Doc#doc.id, [deleted])),
    % Only works when the document has never existed to match CouchDB 3.x
    % behavior
    ?assertThrow(conflict, fabric2_db:update_doc(Db, Doc)).

conflict_on_recreate_as_deleted({Db, _}) ->
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        body = {[{<<"state">>, 1}]}
    },
    {ok, {Pos1, Rev1}} = fabric2_db:update_doc(Db, Doc1),
    Doc2 = Doc1#doc{
        revs = {Pos1, [Rev1]},
        deleted = true,
        body = {[{<<"state">>, 2}]}
    },
    {ok, _} = fabric2_db:update_doc(Db, Doc2),
    Doc3 = Doc1#doc{
        revs = {0, []},
        deleted = true,
        body = {[{<<"state">>, 3}]}
    },
    ?assertThrow(conflict, fabric2_db:update_doc(Db, Doc3)).

conflict_on_extend_deleted({Db, _}) ->
    Doc1 = #doc{
        id = fabric2_util:uuid(),
        body = {[{<<"state">>, 1}]}
    },
    {ok, {Pos1, Rev1}} = fabric2_db:update_doc(Db, Doc1),
    Doc2 = Doc1#doc{
        revs = {Pos1, [Rev1]},
        deleted = true,
        body = {[{<<"state">>, 2}]}
    },
    {ok, {Pos2, Rev2}} = fabric2_db:update_doc(Db, Doc2),
    Doc3 = Doc1#doc{
        revs = {Pos2, [Rev2]},
        deleted = false,
        body = {[{<<"state">>, 3}]}
    },
    ?assertThrow(conflict, fabric2_db:update_doc(Db, Doc3)).

open_doc_revs_basic({Db, _}) ->
    [Rev1, Rev2, Rev3] = lists:sort([
        fabric2_util:uuid(),
        fabric2_util:uuid(),
        fabric2_util:uuid()
    ]),
    DocId = fabric2_util:uuid(),
    Doc1 = #doc{
        id = DocId,
        revs = {2, [Rev3, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    Doc2 = Doc1#doc{
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"bar">>, <<"foo">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),

    {ok, [{ok, Doc3}]} = fabric2_db:open_doc_revs(Db, DocId, [{2, Rev3}], []),
    ?assertEqual(Doc1, Doc3),

    {ok, [{ok, Doc4}]} = fabric2_db:open_doc_revs(Db, DocId, [{2, Rev2}], []),
    ?assertEqual(Doc2, Doc4),

    Revs = [{2, Rev3}, {2, Rev2}, {1, Rev1}],
    {ok, Docs} = fabric2_db:open_doc_revs(Db, DocId, Revs, []),
    ?assert(length(Docs) == 3),
    ?assert(lists:member({ok, Doc1}, Docs)),
    ?assert(lists:member({ok, Doc2}, Docs)),
    ?assert(lists:member({{not_found, missing}, {1, Rev1}}, Docs)),

    % Make sure crazy madeup revisions are accepted
    MissingRevs = [{5, fabric2_util:uuid()}, {1, fabric2_util:uuid()}],
    {ok, NFMissing} = fabric2_db:open_doc_revs(Db, DocId, MissingRevs, []),
    ?assertEqual(2, length(NFMissing)),
    lists:foreach(
        fun(MR) ->
            ?assert(lists:member({{not_found, missing}, MR}, NFMissing))
        end,
        MissingRevs
    ).

open_doc_revs_all({Db, _}) ->
    [Rev1, Rev2, Rev3] = lists:sort([
        fabric2_util:uuid(),
        fabric2_util:uuid(),
        fabric2_util:uuid()
    ]),
    DocId = fabric2_util:uuid(),
    Doc1 = #doc{
        id = DocId,
        revs = {2, [Rev3, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    Doc2 = Doc1#doc{
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"bar">>, <<"foo">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),

    {ok, Docs} = fabric2_db:open_doc_revs(Db, DocId, all, []),
    ?assert(length(Docs) == 2),
    ?assert(lists:member({ok, Doc1}, Docs)),
    ?assert(lists:member({ok, Doc2}, Docs)).

open_doc_revs_latest({Db, _}) ->
    [Rev1, Rev2, Rev3] = lists:sort([
        fabric2_util:uuid(),
        fabric2_util:uuid(),
        fabric2_util:uuid()
    ]),
    DocId = fabric2_util:uuid(),
    Doc1 = #doc{
        id = DocId,
        revs = {2, [Rev3, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    Doc2 = Doc1#doc{
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"bar">>, <<"foo">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),

    Opts = [latest],
    {ok, [{ok, Doc3}]} = fabric2_db:open_doc_revs(Db, DocId, [{2, Rev3}], Opts),
    ?assertEqual(Doc1, Doc3),

    {ok, Docs} = fabric2_db:open_doc_revs(Db, DocId, [{1, Rev1}], Opts),
    ?assert(length(Docs) == 2),
    ?assert(lists:member({ok, Doc1}, Docs)),
    ?assert(lists:member({ok, Doc2}, Docs)).

get_missing_revs_basic({Db, _}) ->
    [Rev1, Rev2, Rev3] = lists:sort([
        fabric2_util:uuid(),
        fabric2_util:uuid(),
        fabric2_util:uuid()
    ]),
    DocId = fabric2_util:uuid(),
    Doc1 = #doc{
        id = DocId,
        revs = {2, [Rev3, Rev1]},
        body = {[{<<"foo">>, <<"bar">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc1, [replicated_changes]),
    Doc2 = Doc1#doc{
        revs = {2, [Rev2, Rev1]},
        body = {[{<<"bar">>, <<"foo">>}]}
    },
    {ok, {2, _}} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),

    % Check that we can find all revisions
    AllRevs = [{1, Rev1}, {2, Rev2}, {2, Rev3}],
    ?assertEqual(
        {ok, []},
        fabric2_db:get_missing_revs(Db, [{DocId, AllRevs}])
    ),

    % Check that a missing revision is found with no possible ancestors
    MissingRev = {2, fabric2_util:uuid()},
    ?assertEqual(
        {ok, [{DocId, [MissingRev], []}]},
        fabric2_db:get_missing_revs(Db, [{DocId, [MissingRev]}])
    ),

    % Check that only a missing rev is returned
    ?assertEqual(
        {ok, [{DocId, [MissingRev], []}]},
        fabric2_db:get_missing_revs(Db, [{DocId, [MissingRev | AllRevs]}])
    ),

    % Check that we can find possible ancestors
    MissingWithAncestors = {4, fabric2_util:uuid()},
    PossibleAncestors = [{2, Rev2}, {2, Rev3}],
    ?assertEqual(
        {ok, [{DocId, [MissingWithAncestors], PossibleAncestors}]},
        fabric2_db:get_missing_revs(Db, [{DocId, [MissingWithAncestors]}])
    ).

get_missing_revs_on_missing_doc({Db, _}) ->
    Revs = lists:sort([
        couch_doc:rev_to_str({1, fabric2_util:uuid()}),
        couch_doc:rev_to_str({2, fabric2_util:uuid()}),
        couch_doc:rev_to_str({800, fabric2_util:uuid()})
    ]),
    DocId = fabric2_util:uuid(),
    {ok, Resp} = fabric2_db:get_missing_revs(Db, [{DocId, Revs}]),
    ?assertMatch([{DocId, [_ | _], []}], Resp),
    [{DocId, Missing, _}] = Resp,
    MissingStrs = [couch_doc:rev_to_str(Rev) || Rev <- Missing],
    ?assertEqual(Revs, lists:sort(MissingStrs)).

open_missing_local_doc({Db, _}) ->
    ?assertEqual(
        {not_found, missing},
        fabric2_db:open_doc(Db, <<"_local/foo">>, [])
    ).

create_local_doc_basic({Db, _}) ->
    UUID = fabric2_util:uuid(),
    LDocId = <<?LOCAL_DOC_PREFIX, UUID/binary>>,
    Doc1 = #doc{
        id = LDocId,
        revs = {0, []},
        deleted = false,
        body = {[{<<"ohai">>, <<"there">>}]}
    },
    ?assertEqual({ok, {0, <<"1">>}}, fabric2_db:update_doc(Db, Doc1)),
    {ok, Doc2} = fabric2_db:open_doc(Db, Doc1#doc.id, []),
    ?assertEqual(Doc1#doc{revs = {0, [<<"1">>]}}, Doc2).

update_local_doc_basic({Db, _}) ->
    UUID = fabric2_util:uuid(),
    LDocId = <<?LOCAL_DOC_PREFIX, UUID/binary>>,
    Doc1 = #doc{
        id = LDocId,
        revs = {0, []},
        deleted = false,
        body = {[{<<"ohai">>, <<"there">>}]}
    },
    ?assertEqual({ok, {0, <<"1">>}}, fabric2_db:update_doc(Db, Doc1)),
    Doc2 = Doc1#doc{
        revs = {0, [<<"1">>]},
        body = {[{<<"whiz">>, <<"bang">>}]}
    },
    ?assertEqual({ok, {0, <<"2">>}}, fabric2_db:update_doc(Db, Doc2)),
    {ok, Doc3} = fabric2_db:open_doc(Db, Doc1#doc.id, []),
    ?assertEqual(Doc2#doc{revs = {0, [<<"2">>]}}, Doc3).

delete_local_doc_basic({Db, _}) ->
    UUID = fabric2_util:uuid(),
    LDocId = <<?LOCAL_DOC_PREFIX, UUID/binary>>,
    Doc1 = #doc{
        id = LDocId,
        revs = {0, []},
        deleted = false,
        body = {[{<<"ohai">>, <<"there">>}]}
    },
    ?assertEqual({ok, {0, <<"1">>}}, fabric2_db:update_doc(Db, Doc1)),
    Doc2 = Doc1#doc{
        revs = {0, [<<"1">>]},
        deleted = true,
        body = {[]}
    },
    ?assertEqual({ok, {0, <<"0">>}}, fabric2_db:update_doc(Db, Doc2)),
    ?assertEqual(
        {not_found, missing},
        fabric2_db:open_doc(Db, LDocId)
    ).

recreate_local_doc({Db, _}) ->
    UUID = fabric2_util:uuid(),
    LDocId = <<?LOCAL_DOC_PREFIX, UUID/binary>>,
    Doc1 = #doc{
        id = LDocId,
        revs = {0, []},
        deleted = false,
        body = {[{<<"ohai">>, <<"there">>}]}
    },
    ?assertEqual({ok, {0, <<"1">>}}, fabric2_db:update_doc(Db, Doc1)),
    Doc2 = Doc1#doc{
        revs = {0, [<<"1">>]},
        deleted = true,
        body = {[]}
    },
    ?assertEqual({ok, {0, <<"0">>}}, fabric2_db:update_doc(Db, Doc2)),
    ?assertEqual(
        {not_found, missing},
        fabric2_db:open_doc(Db, LDocId)
    ),

    ?assertEqual({ok, {0, <<"1">>}}, fabric2_db:update_doc(Db, Doc1)),
    {ok, Doc3} = fabric2_db:open_doc(Db, LDocId),
    ?assertEqual(Doc1#doc{revs = {0, [<<"1">>]}}, Doc3).

create_local_doc_bad_rev({Db, _}) ->
    UUID = fabric2_util:uuid(),
    LDocId = <<?LOCAL_DOC_PREFIX, UUID/binary>>,
    Doc1 = #doc{
        id = LDocId,
        revs = {0, [<<"not a number">>]}
    },
    ?assertThrow(<<"Invalid rev format">>, fabric2_db:update_doc(Db, Doc1)),

    Doc2 = Doc1#doc{
        revs = bad_bad_rev_roy_brown
    },
    ?assertThrow(<<"Invalid rev format">>, fabric2_db:update_doc(Db, Doc2)).

create_local_doc_random_rev({Db, _}) ->
    % Local docs don't care what rev is passed as long
    % as long as its a number.
    UUID = fabric2_util:uuid(),
    LDocId = <<?LOCAL_DOC_PREFIX, UUID/binary>>,
    Doc1 = #doc{
        id = LDocId,
        revs = {0, [<<"42">>]},
        body = {[{<<"state">>, 1}]}
    },
    ?assertEqual({ok, {0, <<"43">>}}, fabric2_db:update_doc(Db, Doc1)),
    {ok, Doc2} = fabric2_db:open_doc(Db, LDocId, []),
    ?assertEqual(Doc1#doc{revs = {0, [<<"43">>]}}, Doc2),

    Doc3 = Doc1#doc{
        revs = {0, [<<"1234567890">>]},
        body = {[{<<"state">>, 2}]}
    },
    ?assertEqual({ok, {0, <<"1234567891">>}}, fabric2_db:update_doc(Db, Doc3)),
    {ok, Doc4} = fabric2_db:open_doc(Db, LDocId, []),
    ?assertEqual(Doc3#doc{revs = {0, [<<"1234567891">>]}}, Doc4),

    Doc5 = Doc1#doc{
        revs = {0, [<<"1">>]},
        body = {[{<<"state">>, 3}]}
    },
    ?assertEqual({ok, {0, <<"2">>}}, fabric2_db:update_doc(Db, Doc5)),
    {ok, Doc6} = fabric2_db:open_doc(Db, LDocId, []),
    ?assertEqual(Doc5#doc{revs = {0, [<<"2">>]}}, Doc6).

create_a_large_local_doc({Db, _}) ->
    UUID = fabric2_util:uuid(),
    LDocId = <<?LOCAL_DOC_PREFIX, UUID/binary>>,
    Body = <<<<"x">> || _ <- lists:seq(1, 300000)>>,
    Doc1 = #doc{
        id = LDocId,
        revs = {0, []},
        body = Body
    },
    ?assertEqual({ok, {0, <<"1">>}}, fabric2_db:update_doc(Db, Doc1)),
    {ok, Doc2} = fabric2_db:open_doc(Db, Doc1#doc.id, []),
    ?assertEqual(Doc1#doc{revs = {0, [<<"1">>]}}, Doc2),

    % Read via fold_local_docs
    {ok, Result} = fabric2_db:fold_local_docs(
        Db,
        fun(Data, Acc) ->
            case Data of
                {row, [{id, DocId} | _]} when LDocId =:= DocId ->
                    {ok, [Data | Acc]};
                _ ->
                    {ok, Acc}
            end
        end,
        [],
        []
    ),
    ?assertEqual(
        [
            {row, [
                {id, LDocId},
                {key, LDocId},
                {value, {[{rev, <<"0-1">>}]}}
            ]}
        ],
        Result
    ).

create_2_large_local_docs({Db, _}) ->
    % Create a large doc then overwrite with a smaller one. The reason is to
    % ensure the previous one correctly clears its range before writting the
    % new smaller one it its place.
    UUID = fabric2_util:uuid(),
    LDocId = <<?LOCAL_DOC_PREFIX, UUID/binary>>,
    Body1 = <<<<"x">> || _ <- lists:seq(1, 400000)>>,
    Body2 = <<<<"y">> || _ <- lists:seq(1, 150000)>>,

    Doc1 = #doc{
        id = LDocId,
        revs = {0, []},
        body = Body1
    },

    ?assertEqual({ok, {0, <<"1">>}}, fabric2_db:update_doc(Db, Doc1)),

    Doc2 = Doc1#doc{body = Body2},
    ?assertEqual({ok, {0, <<"1">>}}, fabric2_db:update_doc(Db, Doc2)),

    {ok, Doc3} = fabric2_db:open_doc(Db, LDocId, []),
    ?assertEqual(Doc2#doc{revs = {0, [<<"1">>]}}, Doc3).

local_doc_with_previous_encoding({Db, _}) ->
    #{db_prefix := DbPrefix} = Db,

    Id = <<"_local/old_doc">>,
    Body = {[{<<"x">>, 5}]},
    Rev = <<"1">>,
    Key = erlfdb_tuple:pack({?DB_LOCAL_DOCS, Id}, DbPrefix),

    fabric2_fdb:transactional(Db, fun(TxDb) ->
        #{tx := Tx} = TxDb,
        Term = term_to_binary({Rev, Body}, [{minor_version, 1}]),
        ok = erlfdb:set(Tx, Key, Term)
    end),

    % Read old doc
    {ok, Doc1} = fabric2_db:open_doc(Db, Id, []),
    ?assertEqual({0, [<<"1">>]}, Doc1#doc.revs),
    ?assertEqual({[{<<"x">>, 5}]}, Doc1#doc.body),

    % Read via fold_local_docs.
    {ok, Result} = fabric2_db:fold_local_docs(
        Db,
        fun(Data, Acc) ->
            case Data of
                {row, [{id, DocId} | _]} when Id =:= DocId ->
                    {ok, [Data | Acc]};
                _ ->
                    {ok, Acc}
            end
        end,
        [],
        []
    ),
    ?assertEqual(
        [
            {row, [
                {id, Id},
                {key, Id},
                {value, {[{rev, <<"0-1">>}]}}
            ]}
        ],
        Result
    ),

    % Update doc
    NewBody = {[{<<"y">>, 6}]},
    Doc2 = Doc1#doc{body = NewBody},
    ?assertEqual({ok, {0, <<"2">>}}, fabric2_db:update_doc(Db, Doc2)),
    {ok, Doc3} = fabric2_db:open_doc(Db, Doc2#doc.id, []),
    ?assertEqual({0, [<<"2">>]}, Doc3#doc.revs),
    ?assertEqual(NewBody, Doc3#doc.body),

    % Old doc now has only the rev number in it
    <<255, OldDocBin/binary>> = fabric2_fdb:transactional(Db, fun(TxDb) ->
        #{tx := Tx} = TxDb,
        erlfdb:wait(erlfdb:get(Tx, Key))
    end),
    Unpacked = erlfdb_tuple:unpack(OldDocBin),
    ?assertMatch({?CURR_LDOC_FORMAT, <<"2">>, _}, Unpacked).

before_doc_update_skips_local_docs({Db0, _}) ->
    BduFun = fun(Doc, _, _) ->
        Doc#doc{body = {[<<"bdu_was_here">>, true]}}
    end,

    Db = Db0#{before_doc_update := BduFun},

    LDoc1 = #doc{id = <<"_local/ldoc1">>},
    Doc1 = #doc{id = <<"doc1">>},

    ?assertMatch({ok, {_, _}}, fabric2_db:update_doc(Db, LDoc1)),
    ?assertMatch({ok, {_, _}}, fabric2_db:update_doc(Db, Doc1)),

    {ok, LDoc2} = fabric2_db:open_doc(Db, LDoc1#doc.id),
    {ok, Doc2} = fabric2_db:open_doc(Db, Doc1#doc.id),

    ?assertEqual({[]}, LDoc2#doc.body),
    ?assertEqual({[<<"bdu_was_here">>, true]}, Doc2#doc.body).

open_doc_opts({Db, _}) ->
    % Build out state so that we can exercise each doc
    % open option. This requires a live revision with
    % an attachment, a conflict, and a deleted conflict.
    DocId = couch_uuids:random(),
    Att1 = couch_att:new([
        {name, <<"foo.txt">>},
        {type, <<"application/octet-stream">>},
        {att_len, 6},
        {data, <<"foobar">>},
        {encoding, identity},
        {md5, <<>>}
    ]),
    Doc1A = #doc{
        id = DocId,
        atts = [Att1]
    },
    {ok, {Pos1, Rev1A}} = fabric2_db:update_doc(Db, Doc1A),
    Att2 = couch_att:store(
        [
            {data, stub},
            {revpos, 1}
        ],
        Att1
    ),
    Doc1B = Doc1A#doc{
        revs = {Pos1, [Rev1A]},
        atts = [Att2]
    },
    {ok, {Pos2, Rev1B}} = fabric2_db:update_doc(Db, Doc1B),

    Rev2 = crypto:strong_rand_bytes(16),
    Rev3 = crypto:strong_rand_bytes(16),
    Rev4 = crypto:strong_rand_bytes(16),

    % Create a live conflict
    Doc2 = #doc{
        id = DocId,
        revs = {1, [Rev2]}
    },
    {ok, _} = fabric2_db:update_doc(Db, Doc2, [replicated_changes]),

    % Create a deleted conflict
    Doc3 = #doc{
        id = DocId,
        revs = {1, [Rev3]}
    },
    {ok, _} = fabric2_db:update_doc(Db, Doc3, [replicated_changes]),
    Doc4 = #doc{
        id = DocId,
        revs = {2, [Rev4, Rev3]},
        deleted = true
    },
    {ok, _} = fabric2_db:update_doc(Db, Doc4, [replicated_changes]),

    OpenOpts1 = [
        revs_info,
        conflicts,
        deleted_conflicts,
        local_seq,
        {atts_since, [{Pos1, Rev1A}]}
    ],
    {ok, OpenedDoc1} = fabric2_db:open_doc(Db, DocId, OpenOpts1),

    #doc{
        id = DocId,
        revs = {2, [Rev1B, Rev1A]},
        atts = [Att3],
        meta = Meta
    } = OpenedDoc1,
    ?assertEqual(stub, couch_att:fetch(data, Att3)),
    ?assertEqual(
        {revs_info, Pos2, [{Rev1B, available}, {Rev1A, missing}]},
        lists:keyfind(revs_info, 1, Meta)
    ),
    ?assertEqual(
        {conflicts, [{1, Rev2}]},
        lists:keyfind(conflicts, 1, Meta)
    ),
    ?assertEqual(
        {deleted_conflicts, [{2, Rev4}]},
        lists:keyfind(deleted_conflicts, 1, Meta)
    ),
    ?assertMatch({_, <<_/binary>>}, lists:keyfind(local_seq, 1, Meta)),

    % Empty atts_since list
    {ok, OpenedDoc2} = fabric2_db:open_doc(Db, DocId, [{atts_since, []}]),
    #doc{atts = [Att4]} = OpenedDoc2,
    ?assertNotEqual(stub, couch_att:fetch(data, Att4)),

    % Missing ancestor
    Rev5 = crypto:strong_rand_bytes(16),
    OpenOpts2 = [{atts_since, [{5, Rev5}]}],
    {ok, OpenedDoc3} = fabric2_db:open_doc(Db, DocId, OpenOpts2),
    #doc{atts = [Att5]} = OpenedDoc3,
    ?assertNotEqual(stub, couch_att:fetch(data, Att5)).