You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@couchdb.apache.org by ji...@apache.org on 2025/03/12 20:43:55 UTC
(couchdb) 02/02: Simplify tests with `?TDEF` and `?TDEF_FE`
This is an automated email from the ASF dual-hosted git repository.
jiahuili430 pushed a commit to branch cleanup-meck-in-fabric
in repository https://gitbox.apache.org/repos/asf/couchdb.git
commit 22ec48973497e8c74a8e8e15eedfc3e05a4bbc57
Author: Jiahui Li <li...@gmail.com>
AuthorDate: Wed Mar 12 15:41:33 2025 -0500
Simplify tests with `?TDEF` and `?TDEF_FE`
---
src/fabric/src/fabric.erl | 12 +-
src/fabric/src/fabric_doc_open.erl | 711 ++++++++++++++++++-------------------
2 files changed, 349 insertions(+), 374 deletions(-)
diff --git a/src/fabric/src/fabric.erl b/src/fabric/src/fabric.erl
index 93a71b035..a5ac3afdc 100644
--- a/src/fabric/src/fabric.erl
+++ b/src/fabric/src/fabric.erl
@@ -761,7 +761,7 @@ set_namespace(NS, #mrargs{extra = Extra} = Args) ->
Args#mrargs{extra = [{namespace, NS} | Extra]}.
-ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
+-include_lib("couch/include/couch_eunit.hrl").
update_doc_test_() ->
{
@@ -770,18 +770,12 @@ update_doc_test_() ->
setup,
fun setup/0,
fun teardown/1,
- fun(Ctx) ->
- [
- should_throw_conflict(Ctx)
- ]
- end
+ with([?TDEF(should_throw_conflict)])
}
}.
should_throw_conflict(Doc) ->
- ?_test(begin
- ?assertThrow(conflict, update_doc(<<"test-db">>, Doc, []))
- end).
+ ?assertThrow(conflict, update_doc(<<"test-db">>, Doc, [])).
setup() ->
Doc = #doc{
diff --git a/src/fabric/src/fabric_doc_open.erl b/src/fabric/src/fabric_doc_open.erl
index d6063907e..46228c0c0 100644
--- a/src/fabric/src/fabric_doc_open.erl
+++ b/src/fabric/src/fabric_doc_open.erl
@@ -196,7 +196,7 @@ format_reply(Else, _) ->
Else.
-ifdef(TEST).
--include_lib("eunit/include/eunit.hrl").
+-include_lib("couch/include/couch_eunit.hrl").
-define(MECK_MODS, [
couch_log,
@@ -230,67 +230,65 @@ open_doc_test_() ->
fun setup/0,
fun teardown/1,
[
- t_is_r_met(),
- t_handle_message_down(),
- t_handle_message_exit(),
- t_handle_message_reply(),
- t_store_node_revs(),
- t_read_repair(),
- t_no_read_repair_for_replicator(),
- t_handle_response_quorum_met(),
- t_get_doc_info()
+ ?TDEF_FE(t_is_r_met),
+ ?TDEF_FE(t_handle_message_down),
+ ?TDEF_FE(t_handle_message_exit),
+ ?TDEF_FE(t_handle_message_reply),
+ ?TDEF_FE(t_store_node_revs),
+ ?TDEF_FE(t_read_repair),
+ ?TDEF_FE(t_no_read_repair_for_replicator),
+ ?TDEF_FE(t_handle_response_quorum_met),
+ ?TDEF_FE(t_get_doc_info)
]
}
}.
-t_is_r_met() ->
- ?_test(begin
- Workers0 = [],
- Workers1 = [nil],
- Workers2 = [nil, nil],
-
- SuccessCases = [
- {{true, foo}, [fabric_util:kv(foo, 2)], 2},
- {{true, foo}, [fabric_util:kv(foo, 3)], 2},
- {{true, foo}, [fabric_util:kv(foo, 1)], 1},
- {{true, foo}, [fabric_util:kv(foo, 2), fabric_util:kv(bar, 1)], 2},
- {{true, bar}, [fabric_util:kv(bar, 1), fabric_util:kv(bar, 2)], 2},
- {{true, bar}, [fabric_util:kv(bar, 2), fabric_util:kv(foo, 1)], 2}
- ],
- lists:foreach(
- fun({Expect, Replies, Q}) ->
- ?assertEqual(Expect, is_r_met(Workers0, Replies, Q))
- end,
- SuccessCases
- ),
-
- WaitForMoreCases = [
- {[fabric_util:kv(foo, 1)], 2},
- {[fabric_util:kv(foo, 2)], 3},
- {[fabric_util:kv(foo, 1), fabric_util:kv(bar, 1)], 2}
- ],
- lists:foreach(
- fun({Replies, Q}) ->
- ?assertEqual(wait_for_more, is_r_met(Workers2, Replies, Q))
- end,
- WaitForMoreCases
- ),
-
- FailureCases = [
- {Workers0, [fabric_util:kv(foo, 1)], 2},
- {Workers1, [fabric_util:kv(foo, 1)], 2},
- {Workers1, [fabric_util:kv(foo, 1), fabric_util:kv(bar, 1)], 2},
- {Workers1, [fabric_util:kv(foo, 2)], 3}
- ],
- lists:foreach(
- fun({Workers, Replies, Q}) ->
- ?assertEqual(no_more_workers, is_r_met(Workers, Replies, Q))
- end,
- FailureCases
- )
- end).
+t_is_r_met(_) ->
+ Workers0 = [],
+ Workers1 = [nil],
+ Workers2 = [nil, nil],
+
+ SuccessCases = [
+ {{true, foo}, [fabric_util:kv(foo, 2)], 2},
+ {{true, foo}, [fabric_util:kv(foo, 3)], 2},
+ {{true, foo}, [fabric_util:kv(foo, 1)], 1},
+ {{true, foo}, [fabric_util:kv(foo, 2), fabric_util:kv(bar, 1)], 2},
+ {{true, bar}, [fabric_util:kv(bar, 1), fabric_util:kv(bar, 2)], 2},
+ {{true, bar}, [fabric_util:kv(bar, 2), fabric_util:kv(foo, 1)], 2}
+ ],
+ lists:foreach(
+ fun({Expect, Replies, Q}) ->
+ ?assertEqual(Expect, is_r_met(Workers0, Replies, Q))
+ end,
+ SuccessCases
+ ),
-t_handle_message_down() ->
+ WaitForMoreCases = [
+ {[fabric_util:kv(foo, 1)], 2},
+ {[fabric_util:kv(foo, 2)], 3},
+ {[fabric_util:kv(foo, 1), fabric_util:kv(bar, 1)], 2}
+ ],
+ lists:foreach(
+ fun({Replies, Q}) ->
+ ?assertEqual(wait_for_more, is_r_met(Workers2, Replies, Q))
+ end,
+ WaitForMoreCases
+ ),
+
+ FailureCases = [
+ {Workers0, [fabric_util:kv(foo, 1)], 2},
+ {Workers1, [fabric_util:kv(foo, 1)], 2},
+ {Workers1, [fabric_util:kv(foo, 1), fabric_util:kv(bar, 1)], 2},
+ {Workers1, [fabric_util:kv(foo, 2)], 3}
+ ],
+ lists:foreach(
+ fun({Workers, Replies, Q}) ->
+ ?assertEqual(no_more_workers, is_r_met(Workers, Replies, Q))
+ end,
+ FailureCases
+ ).
+
+t_handle_message_down(_) ->
Node0 = 'foo@localhost',
Node1 = 'bar@localhost',
Down0 = {rexi_DOWN, nil, {nil, Node0}, nil},
@@ -299,141 +297,135 @@ t_handle_message_down() ->
Worker1 = #shard{node = Node1},
Workers1 = Workers0 ++ [Worker1],
- ?_test(begin
- % Stop when no more workers are left
- ?assertEqual(
- {stop, #acc{workers = []}},
- handle_message(Down0, nil, #acc{workers = Workers0})
- ),
-
- % Continue when we have more workers
- ?assertEqual(
- {ok, #acc{workers = [Worker1]}},
- handle_message(Down0, nil, #acc{workers = Workers1})
- ),
-
- % A second DOWN removes the remaining workers
- ?assertEqual(
- {stop, #acc{workers = []}},
- handle_message(Down1, nil, #acc{workers = [Worker1]})
- )
- end).
-
-t_handle_message_exit() ->
+ % Stop when no more workers are left
+ ?assertEqual(
+ {stop, #acc{workers = []}},
+ handle_message(Down0, nil, #acc{workers = Workers0})
+ ),
+
+ % Continue when we have more workers
+ ?assertEqual(
+ {ok, #acc{workers = [Worker1]}},
+ handle_message(Down0, nil, #acc{workers = Workers1})
+ ),
+
+ % A second DOWN removes the remaining workers
+ ?assertEqual(
+ {stop, #acc{workers = []}},
+ handle_message(Down1, nil, #acc{workers = [Worker1]})
+ ).
+
+t_handle_message_exit(_) ->
Exit = {rexi_EXIT, nil},
Worker0 = #shard{ref = erlang:make_ref()},
Worker1 = #shard{ref = erlang:make_ref()},
- ?_test(begin
- % Only removes the specified worker
- ?assertEqual(
- {ok, #acc{workers = [Worker1]}},
- handle_message(Exit, Worker0, #acc{workers = [Worker0, Worker1]})
- ),
-
- ?assertEqual(
- {ok, #acc{workers = [Worker0]}},
- handle_message(Exit, Worker1, #acc{workers = [Worker0, Worker1]})
- ),
-
- % We bail if it was the last worker
- ?assertEqual(
- {stop, #acc{workers = []}},
- handle_message(Exit, Worker0, #acc{workers = [Worker0]})
- )
- end).
-
-t_handle_message_reply() ->
+ % Only removes the specified worker
+ ?assertEqual(
+ {ok, #acc{workers = [Worker1]}},
+ handle_message(Exit, Worker0, #acc{workers = [Worker0, Worker1]})
+ ),
+
+ ?assertEqual(
+ {ok, #acc{workers = [Worker0]}},
+ handle_message(Exit, Worker1, #acc{workers = [Worker0, Worker1]})
+ ),
+
+ % We bail if it was the last worker
+ ?assertEqual(
+ {stop, #acc{workers = []}},
+ handle_message(Exit, Worker0, #acc{workers = [Worker0]})
+ ).
+
+t_handle_message_reply(_) ->
Worker0 = #shard{ref = erlang:make_ref()},
Worker1 = #shard{ref = erlang:make_ref()},
Worker2 = #shard{ref = erlang:make_ref()},
Workers = [Worker0, Worker1, Worker2],
Acc0 = #acc{workers = Workers, r = 2, replies = []},
- ?_test(begin
- ok = meck:expect(rexi, kill_all, fun(_) -> ok end),
-
- % Test that we continue when we haven't met R yet
- ?assertMatch(
- {ok, #acc{
- workers = [Worker0, Worker1],
- replies = [{foo, {foo, 1}}]
- }},
- handle_message(foo, Worker2, Acc0)
- ),
-
- ?assertMatch(
- {ok, #acc{
- workers = [Worker0, Worker1],
- replies = [{bar, {bar, 1}}, {foo, {foo, 1}}]
- }},
- handle_message(bar, Worker2, Acc0#acc{
- replies = [{foo, {foo, 1}}]
- })
- ),
-
- % Test that we don't get a quorum when R isn't met. q_reply
- % isn't set and state remains unchanged and {stop, NewAcc}
- % is returned. Bit subtle on the assertions here.
-
- ?assertMatch(
- {stop, #acc{workers = [], replies = [{foo, {foo, 1}}]}},
- handle_message(foo, Worker0, Acc0#acc{workers = [Worker0]})
- ),
-
- ?assertMatch(
- {stop, #acc{
- workers = [],
- replies = [{bar, {bar, 1}}, {foo, {foo, 1}}]
- }},
- handle_message(bar, Worker0, Acc0#acc{
- workers = [Worker0],
- replies = [{foo, {foo, 1}}]
- })
- ),
-
- % Check that when R is met we stop with a new state and
- % a q_reply.
-
- ?assertMatch(
- {stop, #acc{
- workers = [],
- replies = [{foo, {foo, 2}}],
- state = r_met,
- q_reply = foo
- }},
- handle_message(foo, Worker1, Acc0#acc{
- workers = [Worker0, Worker1],
- replies = [{foo, {foo, 1}}]
- })
- ),
-
- ?assertEqual(
- {stop, #acc{
- workers = [],
- r = 1,
- replies = [{foo, {foo, 1}}],
- state = r_met,
- q_reply = foo
- }},
- handle_message(foo, Worker0, Acc0#acc{r = 1})
- ),
-
- ?assertMatch(
- {stop, #acc{
- workers = [],
- replies = [{bar, {bar, 1}}, {foo, {foo, 2}}],
- state = r_met,
- q_reply = foo
- }},
- handle_message(foo, Worker0, Acc0#acc{
- workers = [Worker0],
- replies = [{bar, {bar, 1}}, {foo, {foo, 1}}]
- })
- )
- end).
-
-t_store_node_revs() ->
+ ok = meck:expect(rexi, kill_all, fun(_) -> ok end),
+
+ % Test that we continue when we haven't met R yet
+ ?assertMatch(
+ {ok, #acc{
+ workers = [Worker0, Worker1],
+ replies = [{foo, {foo, 1}}]
+ }},
+ handle_message(foo, Worker2, Acc0)
+ ),
+
+ ?assertMatch(
+ {ok, #acc{
+ workers = [Worker0, Worker1],
+ replies = [{bar, {bar, 1}}, {foo, {foo, 1}}]
+ }},
+ handle_message(bar, Worker2, Acc0#acc{
+ replies = [{foo, {foo, 1}}]
+ })
+ ),
+
+ % Test that we don't get a quorum when R isn't met. q_reply
+ % isn't set and state remains unchanged and {stop, NewAcc}
+ % is returned. Bit subtle on the assertions here.
+
+ ?assertMatch(
+ {stop, #acc{workers = [], replies = [{foo, {foo, 1}}]}},
+ handle_message(foo, Worker0, Acc0#acc{workers = [Worker0]})
+ ),
+
+ ?assertMatch(
+ {stop, #acc{
+ workers = [],
+ replies = [{bar, {bar, 1}}, {foo, {foo, 1}}]
+ }},
+ handle_message(bar, Worker0, Acc0#acc{
+ workers = [Worker0],
+ replies = [{foo, {foo, 1}}]
+ })
+ ),
+
+ % Check that when R is met we stop with a new state and
+ % a q_reply.
+
+ ?assertMatch(
+ {stop, #acc{
+ workers = [],
+ replies = [{foo, {foo, 2}}],
+ state = r_met,
+ q_reply = foo
+ }},
+ handle_message(foo, Worker1, Acc0#acc{
+ workers = [Worker0, Worker1],
+ replies = [{foo, {foo, 1}}]
+ })
+ ),
+
+ ?assertEqual(
+ {stop, #acc{
+ workers = [],
+ r = 1,
+ replies = [{foo, {foo, 1}}],
+ state = r_met,
+ q_reply = foo
+ }},
+ handle_message(foo, Worker0, Acc0#acc{r = 1})
+ ),
+
+ ?assertMatch(
+ {stop, #acc{
+ workers = [],
+ replies = [{bar, {bar, 1}}, {foo, {foo, 2}}],
+ state = r_met,
+ q_reply = foo
+ }},
+ handle_message(foo, Worker0, Acc0#acc{
+ workers = [Worker0],
+ replies = [{bar, {bar, 1}}, {foo, {foo, 1}}]
+ })
+ ).
+
+t_store_node_revs(_) ->
W1 = #shard{node = w1, ref = erlang:make_ref()},
W2 = #shard{node = w2, ref = erlang:make_ref()},
W3 = #shard{node = w3, ref = erlang:make_ref()},
@@ -443,200 +435,189 @@ t_store_node_revs() ->
InitAcc = #acc{workers = [W1, W2, W3], replies = [], r = 2},
- ?_test(begin
- ok = meck:expect(rexi, kill_all, fun(_) -> ok end),
-
- % Simple case
- {ok, #acc{node_revs = NodeRevs1}} = handle_message(Foo1, W1, InitAcc),
- ?assertEqual([{w1, [{1, <<"foo">>}]}], NodeRevs1),
-
- % Make sure we only hold the head rev
- {ok, #acc{node_revs = NodeRevs2}} = handle_message(Foo2, W1, InitAcc),
- ?assertEqual([{w1, [{2, <<"foo2">>}]}], NodeRevs2),
-
- % Make sure we don't capture anything on error
- {ok, #acc{node_revs = NodeRevs3}} = handle_message(NFM, W1, InitAcc),
- ?assertEqual([], NodeRevs3),
-
- % Make sure we accumulate node revs
- Acc1 = InitAcc#acc{node_revs = [{w1, [{1, <<"foo">>}]}]},
- {ok, #acc{node_revs = NodeRevs4}} = handle_message(Foo2, W2, Acc1),
- ?assertEqual(
- [{w2, [{2, <<"foo2">>}]}, {w1, [{1, <<"foo">>}]}],
- NodeRevs4
- ),
-
- % Make sure rexi_DOWN doesn't modify node_revs
- Down = {rexi_DOWN, nil, {nil, w1}, nil},
- {ok, #acc{node_revs = NodeRevs5}} = handle_message(Down, W2, Acc1),
- ?assertEqual([{w1, [{1, <<"foo">>}]}], NodeRevs5),
-
- % Make sure rexi_EXIT doesn't modify node_revs
- Exit = {rexi_EXIT, reason},
- {ok, #acc{node_revs = NodeRevs6}} = handle_message(Exit, W2, Acc1),
- ?assertEqual([{w1, [{1, <<"foo">>}]}], NodeRevs6),
-
- % Make sure an error doesn't remove any node revs
- {ok, #acc{node_revs = NodeRevs7}} = handle_message(NFM, W2, Acc1),
- ?assertEqual([{w1, [{1, <<"foo">>}]}], NodeRevs7),
-
- % Make sure we have all of our node_revs when meeting
- % quorum
- {ok, Acc2} = handle_message(Foo1, W1, InitAcc),
- {ok, Acc3} = handle_message(Foo2, W2, Acc2),
- {stop, Acc4} = handle_message(NFM, W3, Acc3),
- ?assertEqual(
- [{w2, [{2, <<"foo2">>}]}, {w1, [{1, <<"foo">>}]}],
- Acc4#acc.node_revs
- )
- end).
-
-t_read_repair() ->
+ ok = meck:expect(rexi, kill_all, fun(_) -> ok end),
+
+ % Simple case
+ {ok, #acc{node_revs = NodeRevs1}} = handle_message(Foo1, W1, InitAcc),
+ ?assertEqual([{w1, [{1, <<"foo">>}]}], NodeRevs1),
+
+ % Make sure we only hold the head rev
+ {ok, #acc{node_revs = NodeRevs2}} = handle_message(Foo2, W1, InitAcc),
+ ?assertEqual([{w1, [{2, <<"foo2">>}]}], NodeRevs2),
+
+ % Make sure we don't capture anything on error
+ {ok, #acc{node_revs = NodeRevs3}} = handle_message(NFM, W1, InitAcc),
+ ?assertEqual([], NodeRevs3),
+
+ % Make sure we accumulate node revs
+ Acc1 = InitAcc#acc{node_revs = [{w1, [{1, <<"foo">>}]}]},
+ {ok, #acc{node_revs = NodeRevs4}} = handle_message(Foo2, W2, Acc1),
+ ?assertEqual(
+ [{w2, [{2, <<"foo2">>}]}, {w1, [{1, <<"foo">>}]}],
+ NodeRevs4
+ ),
+
+ % Make sure rexi_DOWN doesn't modify node_revs
+ Down = {rexi_DOWN, nil, {nil, w1}, nil},
+ {ok, #acc{node_revs = NodeRevs5}} = handle_message(Down, W2, Acc1),
+ ?assertEqual([{w1, [{1, <<"foo">>}]}], NodeRevs5),
+
+ % Make sure rexi_EXIT doesn't modify node_revs
+ Exit = {rexi_EXIT, reason},
+ {ok, #acc{node_revs = NodeRevs6}} = handle_message(Exit, W2, Acc1),
+ ?assertEqual([{w1, [{1, <<"foo">>}]}], NodeRevs6),
+
+ % Make sure an error doesn't remove any node revs
+ {ok, #acc{node_revs = NodeRevs7}} = handle_message(NFM, W2, Acc1),
+ ?assertEqual([{w1, [{1, <<"foo">>}]}], NodeRevs7),
+
+ % Make sure we have all of our node_revs when meeting
+ % quorum
+ {ok, Acc2} = handle_message(Foo1, W1, InitAcc),
+ {ok, Acc3} = handle_message(Foo2, W2, Acc2),
+ {stop, Acc4} = handle_message(NFM, W3, Acc3),
+ ?assertEqual(
+ [{w2, [{2, <<"foo2">>}]}, {w1, [{1, <<"foo">>}]}],
+ Acc4#acc.node_revs
+ ).
+
+t_read_repair(_) ->
Foo1 = {ok, #doc{revs = {1, [<<"foo">>]}}},
Foo2 = {ok, #doc{revs = {2, [<<"foo2">>, <<"foo">>]}}},
NFM = {not_found, missing},
- ?_test(begin
- ok = meck:expect(couch_log, notice, fun(_, _) -> ok end),
- ok = meck:expect(couch_stats, increment_counter, fun(_) -> ok end),
-
- % Test when we have actual doc data to repair
- ok = meck:expect(fabric, update_docs, fun(_, [_], _) -> {ok, []} end),
- Acc0 = #acc{
- dbname = <<"name">>,
- replies = [fabric_util:kv(Foo1, 1)]
- },
- ?assertEqual(Foo1, read_repair(Acc0)),
-
- ok = meck:expect(fabric, update_docs, fun(_, [_, _], _) -> {ok, []} end),
- Acc1 = #acc{
- dbname = <<"name">>,
- replies = [fabric_util:kv(Foo1, 1), fabric_util:kv(Foo2, 1)]
- },
- ?assertEqual(Foo2, read_repair(Acc1)),
-
- % Test when we have nothing but errors
- Acc2 = #acc{replies = [fabric_util:kv(NFM, 1)]},
- ?assertEqual(NFM, read_repair(Acc2)),
-
- Acc3 = #acc{replies = [fabric_util:kv(NFM, 1), fabric_util:kv(foo, 2)]},
- ?assertEqual(NFM, read_repair(Acc3)),
-
- Acc4 = #acc{replies = [fabric_util:kv(foo, 1), fabric_util:kv(bar, 1)]},
- ?assertEqual(bar, read_repair(Acc4))
- end).
-
-t_no_read_repair_for_replicator() ->
+ ok = meck:expect(couch_log, notice, fun(_, _) -> ok end),
+ ok = meck:expect(couch_stats, increment_counter, fun(_) -> ok end),
+
+ % Test when we have actual doc data to repair
+ ok = meck:expect(fabric, update_docs, fun(_, [_], _) -> {ok, []} end),
+ Acc0 = #acc{
+ dbname = <<"name">>,
+ replies = [fabric_util:kv(Foo1, 1)]
+ },
+ ?assertEqual(Foo1, read_repair(Acc0)),
+
+ ok = meck:expect(fabric, update_docs, fun(_, [_, _], _) -> {ok, []} end),
+ Acc1 = #acc{
+ dbname = <<"name">>,
+ replies = [fabric_util:kv(Foo1, 1), fabric_util:kv(Foo2, 1)]
+ },
+ ?assertEqual(Foo2, read_repair(Acc1)),
+
+ % Test when we have nothing but errors
+ Acc2 = #acc{replies = [fabric_util:kv(NFM, 1)]},
+ ?assertEqual(NFM, read_repair(Acc2)),
+
+ Acc3 = #acc{replies = [fabric_util:kv(NFM, 1), fabric_util:kv(foo, 2)]},
+ ?assertEqual(NFM, read_repair(Acc3)),
+
+ Acc4 = #acc{replies = [fabric_util:kv(foo, 1), fabric_util:kv(bar, 1)]},
+ ?assertEqual(bar, read_repair(Acc4)).
+
+t_no_read_repair_for_replicator(_) ->
Foo1 = {ok, #doc{revs = {1, [<<"foo">>]}}},
- ?_test(begin
- ok = meck:expect(couch_log, notice, fun(_, _) -> ok end),
- ok = meck:expect(couch_stats, increment_counter, fun(_) -> ok end),
-
- % Test no read_repair took place
- ok = meck:reset(fabric),
- Acc0 = #acc{
- dbname = <<"dbname1/_replicator">>,
- replies = [fabric_util:kv(Foo1, 1)]
- },
- ?assertEqual(Foo1, read_repair(Acc0)),
- timer:sleep(100),
- ?assertNot(meck:called(fabric, update_docs, ['_', '_', '_']))
- end).
-
-t_handle_response_quorum_met() ->
+ ok = meck:expect(couch_log, notice, fun(_, _) -> ok end),
+ ok = meck:expect(couch_stats, increment_counter, fun(_) -> ok end),
+
+ % Test no read_repair took place
+ ok = meck:reset(fabric),
+ Acc0 = #acc{
+ dbname = <<"dbname1/_replicator">>,
+ replies = [fabric_util:kv(Foo1, 1)]
+ },
+ ?assertEqual(Foo1, read_repair(Acc0)),
+ timer:sleep(100),
+ ?assertNot(meck:called(fabric, update_docs, ['_', '_', '_'])).
+
+t_handle_response_quorum_met(_) ->
Foo1 = {ok, #doc{revs = {1, [<<"foo">>]}}},
Foo2 = {ok, #doc{revs = {2, [<<"foo2">>, <<"foo">>]}}},
Bar1 = {ok, #doc{revs = {1, [<<"bar">>]}}},
- ?_test(begin
- ok = meck:expect(couch_log, notice, fun(_, _) -> ok end),
- ok = meck:expect(fabric, update_docs, fun(_, _, _) -> {ok, []} end),
- ok = meck:expect(couch_stats, increment_counter, fun(_) -> ok end),
+ ok = meck:expect(couch_log, notice, fun(_, _) -> ok end),
+ ok = meck:expect(fabric, update_docs, fun(_, _, _) -> {ok, []} end),
+ ok = meck:expect(couch_stats, increment_counter, fun(_) -> ok end),
- BasicOkAcc = #acc{
- dbname = <<"dbname1">>,
- state = r_met,
- replies = [fabric_util:kv(Foo1, 2)],
- q_reply = Foo1
- },
- ?assertEqual(Foo1, handle_response(BasicOkAcc)),
+ BasicOkAcc = #acc{
+ dbname = <<"dbname1">>,
+ state = r_met,
+ replies = [fabric_util:kv(Foo1, 2)],
+ q_reply = Foo1
+ },
+ ?assertEqual(Foo1, handle_response(BasicOkAcc)),
- WithAncestorsAcc = #acc{
- dbname = <<"dbname1">>,
- state = r_met,
- replies = [fabric_util:kv(Foo1, 1), fabric_util:kv(Foo2, 2)],
- q_reply = Foo2
- },
- ?assertEqual(Foo2, handle_response(WithAncestorsAcc)),
-
- % This also checks when the quorum isn't the most recent
- % revision.
- DeeperWinsAcc = #acc{
- dbname = <<"dbname1">>,
- state = r_met,
- replies = [fabric_util:kv(Foo1, 2), fabric_util:kv(Foo2, 1)],
- q_reply = Foo1
- },
- ?assertEqual(Foo2, handle_response(DeeperWinsAcc)),
-
- % Check that we return the proper doc based on rev
- % (ie, pos is equal)
- BiggerRevWinsAcc = #acc{
- dbname = <<"dbname1">>,
- state = r_met,
- replies = [fabric_util:kv(Foo1, 1), fabric_util:kv(Bar1, 2)],
- q_reply = Bar1
- },
- ?assertEqual(Foo1, handle_response(BiggerRevWinsAcc))
-
- % r_not_met is a proxy to read_repair so we rely on
- % read_repair_test for those conditions.
- end).
-
-t_get_doc_info() ->
- ?_test(begin
- ok = meck:expect(fabric, update_docs, fun(_, _, _) -> {ok, []} end),
- ok = meck:expect(couch_stats, increment_counter, fun(_) -> ok end),
- ok = meck:expect(fabric_util, submit_jobs, fun(_, _, _) -> ok end),
- ok = meck:expect(fabric_util, create_monitors, fun(_) -> ok end),
- ok = meck:expect(rexi_monitor, stop, fun(_) -> ok end),
- ok = meck:expect(mem3, shards, fun(_, _) -> ok end),
- ok = meck:expect(mem3, n, fun(_) -> 3 end),
- ok = meck:expect(mem3, quorum, fun(_) -> 2 end),
-
- ok = meck:expect(fabric_util, recv, fun(_, _, _, _) ->
- {ok, #acc{state = r_not_met}}
- end),
- Rsp1 = fabric_doc_open:go("test", "one", [doc_info]),
- ?assertEqual({error, quorum_not_met}, Rsp1),
-
- Rsp2 = fabric_doc_open:go("test", "one", [{doc_info, full}]),
- ?assertEqual({error, quorum_not_met}, Rsp2),
-
- ok = meck:expect(fabric_util, recv, fun(_, _, _, _) ->
- {ok, #acc{state = r_met, q_reply = not_found}}
- end),
- MissingRsp1 = fabric_doc_open:go("test", "one", [doc_info]),
- ?assertEqual({not_found, missing}, MissingRsp1),
- MissingRsp2 = fabric_doc_open:go("test", "one", [{doc_info, full}]),
- ?assertEqual({not_found, missing}, MissingRsp2),
-
- ok = meck:expect(fabric_util, recv, fun(_, _, _, _) ->
- A = #doc_info{},
- {ok, #acc{state = r_met, q_reply = {ok, A}}}
- end),
- {ok, Rec1} = fabric_doc_open:go("test", "one", [doc_info]),
- ?assert(is_record(Rec1, doc_info)),
-
- ok = meck:expect(fabric_util, recv, fun(_, _, _, _) ->
- A = #full_doc_info{deleted = true},
- {ok, #acc{state = r_met, q_reply = {ok, A}}}
- end),
- Rsp3 = fabric_doc_open:go("test", "one", [{doc_info, full}]),
- ?assertEqual({not_found, deleted}, Rsp3),
- {ok, Rec2} = fabric_doc_open:go("test", "one", [{doc_info, full}, deleted]),
- ?assert(is_record(Rec2, full_doc_info))
- end).
+ WithAncestorsAcc = #acc{
+ dbname = <<"dbname1">>,
+ state = r_met,
+ replies = [fabric_util:kv(Foo1, 1), fabric_util:kv(Foo2, 2)],
+ q_reply = Foo2
+ },
+ ?assertEqual(Foo2, handle_response(WithAncestorsAcc)),
+
+ % This also checks when the quorum isn't the most recent
+ % revision.
+ DeeperWinsAcc = #acc{
+ dbname = <<"dbname1">>,
+ state = r_met,
+ replies = [fabric_util:kv(Foo1, 2), fabric_util:kv(Foo2, 1)],
+ q_reply = Foo1
+ },
+ ?assertEqual(Foo2, handle_response(DeeperWinsAcc)),
+
+ % Check that we return the proper doc based on rev
+ % (ie, pos is equal)
+ BiggerRevWinsAcc = #acc{
+ dbname = <<"dbname1">>,
+ state = r_met,
+ replies = [fabric_util:kv(Foo1, 1), fabric_util:kv(Bar1, 2)],
+ q_reply = Bar1
+ },
+ ?assertEqual(Foo1, handle_response(BiggerRevWinsAcc)).
+
+% r_not_met is a proxy to read_repair so we rely on
+% read_repair_test for those conditions.
+t_get_doc_info(_) ->
+ ok = meck:expect(fabric, update_docs, fun(_, _, _) -> {ok, []} end),
+ ok = meck:expect(couch_stats, increment_counter, fun(_) -> ok end),
+ ok = meck:expect(fabric_util, submit_jobs, fun(_, _, _) -> ok end),
+ ok = meck:expect(fabric_util, create_monitors, fun(_) -> ok end),
+ ok = meck:expect(rexi_monitor, stop, fun(_) -> ok end),
+ ok = meck:expect(mem3, shards, fun(_, _) -> ok end),
+ ok = meck:expect(mem3, n, fun(_) -> 3 end),
+ ok = meck:expect(mem3, quorum, fun(_) -> 2 end),
+
+ ok = meck:expect(fabric_util, recv, fun(_, _, _, _) ->
+ {ok, #acc{state = r_not_met}}
+ end),
+ Rsp1 = fabric_doc_open:go("test", "one", [doc_info]),
+ ?assertEqual({error, quorum_not_met}, Rsp1),
+
+ Rsp2 = fabric_doc_open:go("test", "one", [{doc_info, full}]),
+ ?assertEqual({error, quorum_not_met}, Rsp2),
+
+ ok = meck:expect(fabric_util, recv, fun(_, _, _, _) ->
+ {ok, #acc{state = r_met, q_reply = not_found}}
+ end),
+ MissingRsp1 = fabric_doc_open:go("test", "one", [doc_info]),
+ ?assertEqual({not_found, missing}, MissingRsp1),
+ MissingRsp2 = fabric_doc_open:go("test", "one", [{doc_info, full}]),
+ ?assertEqual({not_found, missing}, MissingRsp2),
+
+ ok = meck:expect(fabric_util, recv, fun(_, _, _, _) ->
+ A = #doc_info{},
+ {ok, #acc{state = r_met, q_reply = {ok, A}}}
+ end),
+ {ok, Rec1} = fabric_doc_open:go("test", "one", [doc_info]),
+ ?assert(is_record(Rec1, doc_info)),
+
+ ok = meck:expect(fabric_util, recv, fun(_, _, _, _) ->
+ A = #full_doc_info{deleted = true},
+ {ok, #acc{state = r_met, q_reply = {ok, A}}}
+ end),
+ Rsp3 = fabric_doc_open:go("test", "one", [{doc_info, full}]),
+ ?assertEqual({not_found, deleted}, Rsp3),
+ {ok, Rec2} = fabric_doc_open:go("test", "one", [{doc_info, full}, deleted]),
+ ?assert(is_record(Rec2, full_doc_info)).
-endif.