Update PSE test definitions for new util module

9 files changed, 140 insertions, 140 deletions

diff --git a/src/couch_pse_tests/src/cpse_test_attachments.erl b/src/couch_pse_tests/src/cpse_test_attachments.erl
index d8fd2b84b..7372ba40f 100644
--- a/src/couch_pse_tests/src/cpse_test_attachments.erl
+++ b/src/couch_pse_tests/src/cpse_test_attachments.erl
@@ -19,12 +19,12 @@
 
 
 cet_write_attachment() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     AttBin = crypto:strong_rand_bytes(32768),
 
     try
-        [Att0] = test_engine_util:prep_atts(Db1, [
+        [Att0] = cpse_util:prep_atts(Db1, [
                 {<<"ohai.txt">>, AttBin}
             ]),
 
@@ -32,9 +32,9 @@ cet_write_attachment() ->
         ?assertEqual(true, couch_db_engine:is_active_stream(Db1, Stream)),
 
         Actions = [{create, {<<"first">>, {[]}, [Att0]}}],
-        {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+        {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
         {ok, _} = couch_db:ensure_full_commit(Db2),
-        test_engine_util:shutdown_db(Db2),
+        cpse_util:shutdown_db(Db2),
 
         {ok, Db3} = couch_db:reopen(Db2),
 
@@ -44,7 +44,7 @@ cet_write_attachment() ->
             rev = {RevPos, PrevRevId},
             deleted = Deleted,
             body_sp = DocPtr
-        } = test_engine_util:prev_rev(FDI),
+        } = cpse_util:prev_rev(FDI),
 
         Doc0 = #doc{
             id = <<"foo">>,
@@ -73,19 +73,19 @@ cet_write_attachment() ->
 % we ever have something that stores attachemnts in
 % an external object store)
 cet_inactive_stream() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     AttBin = crypto:strong_rand_bytes(32768),
 
     try
-        [Att0] = test_engine_util:prep_atts(Db1, [
+        [Att0] = cpse_util:prep_atts(Db1, [
                 {<<"ohai.txt">>, AttBin}
             ]),
 
         {stream, Stream} = couch_att:fetch(data, Att0),
         ?assertEqual(true, couch_db_engine:is_active_stream(Db1, Stream)),
 
-        test_engine_util:shutdown_db(Db1),
+        cpse_util:shutdown_db(Db1),
         {ok, Db2} = couch_db:reopen(Db1),
 
         ?assertEqual(false, couch_db_engine:is_active_stream(Db2, Stream))
diff --git a/src/couch_pse_tests/src/cpse_test_compaction.erl b/src/couch_pse_tests/src/cpse_test_compaction.erl
index 0c81707b5..122febaeb 100644
--- a/src/couch_pse_tests/src/cpse_test_compaction.erl
+++ b/src/couch_pse_tests/src/cpse_test_compaction.erl
@@ -19,50 +19,50 @@
 
 
 cet_compact_empty() ->
-    {ok, Db1} = test_engine_util:create_db(),
-    Term1 = test_engine_util:db_as_term(Db1),
+    {ok, Db1} = cpse_util:create_db(),
+    Term1 = cpse_util:db_as_term(Db1),
 
-    test_engine_util:compact(Db1),
+    cpse_util:compact(Db1),
 
     {ok, Db2} = couch_db:reopen(Db1),
-    Term2 = test_engine_util:db_as_term(Db2),
+    Term2 = cpse_util:db_as_term(Db2),
 
-    Diff = test_engine_util:term_diff(Term1, Term2),
+    Diff = cpse_util:term_diff(Term1, Term2),
     ?assertEqual(nodiff, Diff).
 
 
 cet_compact_doc() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
     Actions = [{create, {<<"foo">>, {[]}}}],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
-    Term1 = test_engine_util:db_as_term(Db2),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
+    Term1 = cpse_util:db_as_term(Db2),
 
-    test_engine_util:compact(Db2),
+    cpse_util:compact(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
-    Term2 = test_engine_util:db_as_term(Db3),
+    Term2 = cpse_util:db_as_term(Db3),
 
-    Diff = test_engine_util:term_diff(Term1, Term2),
+    Diff = cpse_util:term_diff(Term1, Term2),
     ?assertEqual(nodiff, Diff).
 
 
 cet_compact_local_doc() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
     Actions = [{create, {<<"_local/foo">>, {[]}}}],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
-    Term1 = test_engine_util:db_as_term(Db2),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
+    Term1 = cpse_util:db_as_term(Db2),
 
-    test_engine_util:compact(Db2),
+    cpse_util:compact(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
-    Term2 = test_engine_util:db_as_term(Db3),
+    Term2 = cpse_util:db_as_term(Db3),
 
-    Diff = test_engine_util:term_diff(Term1, Term2),
+    Diff = cpse_util:term_diff(Term1, Term2),
     ?assertEqual(nodiff, Diff).
 
 
 cet_compact_with_everything() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     % Add a whole bunch of docs
     DocActions = lists:map(fun(Seq) ->
@@ -75,7 +75,7 @@ cet_compact_with_everything() ->
 
     Actions1 = DocActions ++ LocalActions,
 
-    {ok, Db2} = test_engine_util:apply_batch(Db1, Actions1),
+    {ok, Db2} = cpse_util:apply_batch(Db1, Actions1),
     ok = couch_db:set_security(Db1, {[{<<"foo">>, <<"bar">>}]}),
     ok = couch_db:set_revs_limit(Db1, 500),
 
@@ -85,12 +85,12 @@ cet_compact_with_everything() ->
         {conflict, {<<"bar">>, {[{<<"booo">>, false}]}}}
     ],
 
-    {ok, Db3} = test_engine_util:apply_actions(Db2, Actions2),
+    {ok, Db3} = cpse_util:apply_actions(Db2, Actions2),
 
     [FooFDI, BarFDI] = couch_db_engine:open_docs(Db3, [<<"foo">>, <<"bar">>]),
 
-    FooRev = test_engine_util:prev_rev(FooFDI),
-    BarRev = test_engine_util:prev_rev(BarFDI),
+    FooRev = cpse_util:prev_rev(FooFDI),
+    BarRev = cpse_util:prev_rev(BarFDI),
 
     Actions3 = [
         {batch, [
@@ -99,7 +99,7 @@ cet_compact_with_everything() ->
         ]}
     ],
 
-    {ok, Db4} = test_engine_util:apply_actions(Db3, Actions3),
+    {ok, Db4} = cpse_util:apply_actions(Db3, Actions3),
 
     PurgedIdRevs = [
         {<<"bar">>, [BarRev#rev_info.rev]},
@@ -112,7 +112,7 @@ cet_compact_with_everything() ->
         ),
 
     {ok, Db5} = try
-        [Att0, Att1, Att2, Att3, Att4] = test_engine_util:prep_atts(Db4, [
+        [Att0, Att1, Att2, Att3, Att4] = cpse_util:prep_atts(Db4, [
                 {<<"ohai.txt">>, crypto:strong_rand_bytes(2048)},
                 {<<"stuff.py">>, crypto:strong_rand_bytes(32768)},
                 {<<"a.erl">>, crypto:strong_rand_bytes(29)},
@@ -125,38 +125,38 @@ cet_compact_with_everything() ->
             {create, {<<"large_att">>, {[]}, [Att1]}},
             {create, {<<"multi_att">>, {[]}, [Att2, Att3, Att4]}}
         ],
-        test_engine_util:apply_actions(Db4, Actions4)
+        cpse_util:apply_actions(Db4, Actions4)
     catch throw:not_supported ->
         {ok, Db4}
     end,
     {ok, _} = couch_db:ensure_full_commit(Db5),
     {ok, Db6} = couch_db:reopen(Db5),
 
-    Term1 = test_engine_util:db_as_term(Db6),
+    Term1 = cpse_util:db_as_term(Db6),
 
     Config = [
         {"database_compaction", "doc_buffer_size", "1024"},
         {"database_compaction", "checkpoint_after", "2048"}
     ],
 
-    test_engine_util:with_config(Config, fun() ->
-        test_engine_util:compact(Db6)
+    cpse_util:with_config(Config, fun() ->
+        cpse_util:compact(Db6)
     end),
 
     {ok, Db7} = couch_db:reopen(Db6),
-    Term2 = test_engine_util:db_as_term(Db7),
+    Term2 = cpse_util:db_as_term(Db7),
 
-    Diff = test_engine_util:term_diff(Term1, Term2),
+    Diff = cpse_util:term_diff(Term1, Term2),
     ?assertEqual(nodiff, Diff).
 
 
 cet_recompact_updates() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     Actions1 = lists:map(fun(Seq) ->
         {create, {docid(Seq), {[{<<"int">>, Seq}]}}}
     end, lists:seq(1, 1000)),
-    {ok, Db2} = test_engine_util:apply_batch(Db1, Actions1),
+    {ok, Db2} = cpse_util:apply_batch(Db1, Actions1),
 
     {ok, Compactor} = couch_db:start_compact(Db2),
     catch erlang:suspend_process(Compactor),
@@ -166,16 +166,16 @@ cet_recompact_updates() ->
         {create, {<<"boop">>, {[]}}}
     ],
 
-    {ok, Db3} = test_engine_util:apply_actions(Db2, Actions2),
-    Term1 = test_engine_util:db_as_term(Db3),
+    {ok, Db3} = cpse_util:apply_actions(Db2, Actions2),
+    Term1 = cpse_util:db_as_term(Db3),
 
     catch erlang:resume_process(Compactor),
-    test_engine_util:compact(Db3),
+    cpse_util:compact(Db3),
 
     {ok, Db4} = couch_db:reopen(Db3),
-    Term2 = test_engine_util:db_as_term(Db4),
+    Term2 = cpse_util:db_as_term(Db4),
 
-    Diff = test_engine_util:term_diff(Term1, Term2),
+    Diff = cpse_util:term_diff(Term1, Term2),
     ?assertEqual(nodiff, Diff).
 
 
diff --git a/src/couch_pse_tests/src/cpse_test_fold_changes.erl b/src/couch_pse_tests/src/cpse_test_fold_changes.erl
index 5ed45c154..64ae34d66 100644
--- a/src/couch_pse_tests/src/cpse_test_fold_changes.erl
+++ b/src/couch_pse_tests/src/cpse_test_fold_changes.erl
@@ -22,16 +22,16 @@
 
 
 cet_empty_changes() ->
-    {ok, Db} = test_engine_util:create_db(),
+    {ok, Db} = cpse_util:create_db(),
     ?assertEqual(0, couch_db_engine:count_changes_since(Db, 0)),
     ?assertEqual({ok, []},
             couch_db_engine:fold_changes(Db, 0, fun fold_fun/2, [], [])).
 
 
 cet_single_change() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
     Actions = [{create, {<<"a">>, {[]}}}],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
 
     ?assertEqual(1, couch_db_engine:count_changes_since(Db2, 0)),
     ?assertEqual({ok, [{<<"a">>, 1}]},
@@ -39,12 +39,12 @@ cet_single_change() ->
 
 
 cet_two_changes() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
     Actions = [
         {create, {<<"a">>, {[]}}},
         {create, {<<"b">>, {[]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
 
     ?assertEqual(2, couch_db_engine:count_changes_since(Db2, 0)),
     {ok, Changes} =
@@ -53,28 +53,28 @@ cet_two_changes() ->
 
 
 cet_two_changes_batch() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
     Actions1 = [
         {batch, [
             {create, {<<"a">>, {[]}}},
             {create, {<<"b">>, {[]}}}
         ]}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions1),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions1),
 
     ?assertEqual(2, couch_db_engine:count_changes_since(Db2, 0)),
     {ok, Changes1} =
             couch_db_engine:fold_changes(Db2, 0, fun fold_fun/2, [], []),
     ?assertEqual([{<<"a">>, 1}, {<<"b">>, 2}], lists:reverse(Changes1)),
 
-    {ok, Db3} = test_engine_util:create_db(),
+    {ok, Db3} = cpse_util:create_db(),
     Actions2 = [
         {batch, [
             {create, {<<"b">>, {[]}}},
             {create, {<<"a">>, {[]}}}
         ]}
     ],
-    {ok, Db4} = test_engine_util:apply_actions(Db3, Actions2),
+    {ok, Db4} = cpse_util:apply_actions(Db3, Actions2),
 
     ?assertEqual(2, couch_db_engine:count_changes_since(Db4, 0)),
     {ok, Changes2} =
@@ -83,12 +83,12 @@ cet_two_changes_batch() ->
 
 
 cet_update_one() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
     Actions = [
         {create, {<<"a">>, {[]}}},
         {update, {<<"a">>, {[]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
 
     ?assertEqual(1, couch_db_engine:count_changes_since(Db2, 0)),
     ?assertEqual({ok, [{<<"a">>, 2}]},
@@ -96,13 +96,13 @@ cet_update_one() ->
 
 
 cet_update_first_of_two() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
     Actions = [
         {create, {<<"a">>, {[]}}},
         {create, {<<"b">>, {[]}}},
         {update, {<<"a">>, {[]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
 
     ?assertEqual(2, couch_db_engine:count_changes_since(Db2, 0)),
     {ok, Changes} =
@@ -111,13 +111,13 @@ cet_update_first_of_two() ->
 
 
 cet_update_second_of_two() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
     Actions = [
         {create, {<<"a">>, {[]}}},
         {create, {<<"b">>, {[]}}},
         {update, {<<"b">>, {[]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
 
     ?assertEqual(2, couch_db_engine:count_changes_since(Db2, 0)),
     {ok, Changes} =
@@ -133,8 +133,8 @@ cet_check_mutation_ordering() ->
     DocIdOrder = [DocId || {_, {DocId, _}} <- Actions],
     DocSeqs = lists:zip(DocIdOrder, lists:seq(1, ?NUM_DOCS)),
 
-    {ok, Db1} = test_engine_util:create_db(),
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db1} = cpse_util:create_db(),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
 
     % First lets see that we can get the correct
     % suffix/prefix starting at every update sequence
@@ -158,7 +158,7 @@ do_mutation_ordering(Db, _Seq, [], FinalDocSeqs) ->
 
 do_mutation_ordering(Db, Seq, [{DocId, _OldSeq} | Rest], DocSeqAcc) ->
     Actions = [{update, {DocId, {[]}}}],
-    {ok, NewDb} = test_engine_util:apply_actions(Db, Actions),
+    {ok, NewDb} = cpse_util:apply_actions(Db, Actions),
     NewAcc = DocSeqAcc ++ [{DocId, Seq}],
     Expected = Rest ++ NewAcc,
     {ok, RevOrder} =
diff --git a/src/couch_pse_tests/src/cpse_test_fold_docs.erl b/src/couch_pse_tests/src/cpse_test_fold_docs.erl
index fbea7da5b..d9345fed4 100644
--- a/src/couch_pse_tests/src/cpse_test_fold_docs.erl
+++ b/src/couch_pse_tests/src/cpse_test_fold_docs.erl
@@ -353,11 +353,11 @@ fold_user_fun_stop(FoldFun, DocIdFun) ->
 
 
 init_st(DocIdFun) ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
     Actions = lists:map(fun(Id) ->
         {create, {DocIdFun(Id), {[{<<"int">>, Id}]}}}
     end, lists:seq(1, ?NUM_DOCS)),
-    test_engine_util:apply_batch(Db1, Actions).
+    cpse_util:apply_batch(Db1, Actions).
 
 
 fold_fun(Doc, Acc) ->
diff --git a/src/couch_pse_tests/src/cpse_test_get_set_props.erl b/src/couch_pse_tests/src/cpse_test_get_set_props.erl
index 678f0cb2b..e11f76031 100644
--- a/src/couch_pse_tests/src/cpse_test_get_set_props.erl
+++ b/src/couch_pse_tests/src/cpse_test_get_set_props.erl
@@ -19,7 +19,7 @@
 
 cet_default_props() ->
     {ok, {_App, Engine, _Extension}} = application:get_env(couch, test_engine),
-    {ok, Db} = test_engine_util:create_db(),
+    {ok, Db} = cpse_util:create_db(),
     Node = node(),
 
     ?assertEqual(Engine, couch_db_engine:get_engine(Db)),
@@ -49,12 +49,12 @@ cet_default_props() ->
 
 cet_admin_only_security() ->
     Config = [{"couchdb", "default_security", "admin_only"}],
-    {ok, Db1} = test_engine_util:with_config(Config, fun() ->
-        test_engine_util:create_db()
+    {ok, Db1} = cpse_util:with_config(Config, fun() ->
+        cpse_util:create_db()
     end),
 
     ?assertEqual(?ADMIN_ONLY_SEC_PROPS, couch_db:get_security(Db1)),
-    test_engine_util:shutdown_db(Db1),
+    cpse_util:shutdown_db(Db1),
 
     {ok, Db2} = couch_db:reopen(Db1),
     couch_log:error("~n~n~n~n~s -> ~s~n~n", [couch_db:name(Db1), couch_db:name(Db2)]),
@@ -71,7 +71,7 @@ cet_set_revs_limit() ->
 
 
 check_prop_set(GetFun, SetFun, Default, Value) ->
-    {ok, Db0} = test_engine_util:create_db(),
+    {ok, Db0} = cpse_util:create_db(),
 
     ?assertEqual(Default, couch_db:GetFun(Db0)),
     ?assertMatch(ok, couch_db:SetFun(Db0, Value)),
@@ -80,7 +80,7 @@ check_prop_set(GetFun, SetFun, Default, Value) ->
     ?assertEqual(Value, couch_db:GetFun(Db1)),
 
     ?assertMatch({ok, _}, couch_db:ensure_full_commit(Db1)),
-    test_engine_util:shutdown_db(Db1),
+    cpse_util:shutdown_db(Db1),
 
     {ok, Db2} = couch_db:reopen(Db1),
     ?assertEqual(Value, couch_db:GetFun(Db2)).
diff --git a/src/couch_pse_tests/src/cpse_test_open_close_delete.erl b/src/couch_pse_tests/src/cpse_test_open_close_delete.erl
index 3fb023bb1..86fa339a4 100644
--- a/src/couch_pse_tests/src/cpse_test_open_close_delete.erl
+++ b/src/couch_pse_tests/src/cpse_test_open_close_delete.erl
@@ -20,40 +20,40 @@
 cet_open_non_existent() ->
     % Try twice to check that a failed open doesn't create
     % the database for some reason.
-    DbName = test_engine_util:dbname(),
-    ?assertEqual({not_found, no_db_file}, test_engine_util:open_db(DbName)),
-    ?assertEqual({not_found, no_db_file}, test_engine_util:open_db(DbName)).
+    DbName = cpse_util:dbname(),
+    ?assertEqual({not_found, no_db_file}, cpse_util:open_db(DbName)),
+    ?assertEqual({not_found, no_db_file}, cpse_util:open_db(DbName)).
 
 
 cet_open_create() ->
-    DbName = test_engine_util:dbname(),
+    DbName = cpse_util:dbname(),
 
     ?assertEqual(false, couch_server:exists(DbName)),
-    ?assertEqual({not_found, no_db_file}, test_engine_util:open_db(DbName)),
-    ?assertMatch({ok, _}, test_engine_util:create_db(DbName)),
+    ?assertEqual({not_found, no_db_file}, cpse_util:open_db(DbName)),
+    ?assertMatch({ok, _}, cpse_util:create_db(DbName)),
     ?assertEqual(true, couch_server:exists(DbName)).
 
 
 cet_open_when_exists() ->
-    DbName = test_engine_util:dbname(),
+    DbName = cpse_util:dbname(),
 
     ?assertEqual(false, couch_server:exists(DbName)),
-    ?assertEqual({not_found, no_db_file}, test_engine_util:open_db(DbName)),
-    ?assertMatch({ok, _}, test_engine_util:create_db(DbName)),
-    ?assertEqual(file_exists, test_engine_util:create_db(DbName)).
+    ?assertEqual({not_found, no_db_file}, cpse_util:open_db(DbName)),
+    ?assertMatch({ok, _}, cpse_util:create_db(DbName)),
+    ?assertEqual(file_exists, cpse_util:create_db(DbName)).
 
 
 cet_terminate() ->
-    DbName = test_engine_util:dbname(),
+    DbName = cpse_util:dbname(),
 
     ?assertEqual(false, couch_server:exists(DbName)),
-    ?assertEqual({not_found, no_db_file}, test_engine_util:open_db(DbName)),
+    ?assertEqual({not_found, no_db_file}, cpse_util:open_db(DbName)),
     ?assertEqual(ok, cycle_db(DbName, create_db)),
     ?assertEqual(true, couch_server:exists(DbName)).
 
 
 cet_rapid_recycle() ->
-    DbName = test_engine_util:dbname(),
+    DbName = cpse_util:dbname(),
 
     ?assertEqual(ok, cycle_db(DbName, create_db)),
     lists:foreach(fun(_) ->
@@ -62,7 +62,7 @@ cet_rapid_recycle() ->
 
 
 cet_delete() ->
-    DbName = test_engine_util:dbname(),
+    DbName = cpse_util:dbname(),
 
     ?assertEqual(false, couch_server:exists(DbName)),
     ?assertMatch(ok, cycle_db(DbName, create_db)),
@@ -72,5 +72,5 @@ cet_delete() ->
 
 
 cycle_db(DbName, Type) ->
-    {ok, Db} = test_engine_util:Type(DbName),
-    test_engine_util:shutdown_db(Db).
+    {ok, Db} = cpse_util:Type(DbName),
+    cpse_util:shutdown_db(Db).
diff --git a/src/couch_pse_tests/src/cpse_test_purge_docs.erl b/src/couch_pse_tests/src/cpse_test_purge_docs.erl
index d90faeee2..19303c233 100644
--- a/src/couch_pse_tests/src/cpse_test_purge_docs.erl
+++ b/src/couch_pse_tests/src/cpse_test_purge_docs.erl
@@ -19,12 +19,12 @@
 
 
 cet_purge_simple() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     Actions1 = [
         {create, {<<"foo">>, {[{<<"vsn">>, 1}]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions1),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions1),
 
     ?assertEqual(1, couch_db_engine:get_doc_count(Db2)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db2)),
@@ -33,13 +33,13 @@ cet_purge_simple() ->
     ?assertEqual([], couch_db_engine:get_last_purged(Db2)),
 
     [FDI] = couch_db_engine:open_docs(Db2, [<<"foo">>]),
-    PrevRev = test_engine_util:prev_rev(FDI),
+    PrevRev = cpse_util:prev_rev(FDI),
     Rev = PrevRev#rev_info.rev,
 
     Actions2 = [
         {purge, {<<"foo">>, Rev}}
     ],
-    {ok, Db3} = test_engine_util:apply_actions(Db2, Actions2),
+    {ok, Db3} = cpse_util:apply_actions(Db2, Actions2),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db3)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db3)),
@@ -49,13 +49,13 @@ cet_purge_simple() ->
 
 
 cet_purge_conflicts() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     Actions1 = [
         {create, {<<"foo">>, {[{<<"vsn">>, 1}]}}},
         {conflict, {<<"foo">>, {[{<<"vsn">>, 2}]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions1),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions1),
 
     ?assertEqual(1, couch_db_engine:get_doc_count(Db2)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db2)),
@@ -64,13 +64,13 @@ cet_purge_conflicts() ->
     ?assertEqual([], couch_db_engine:get_last_purged(Db2)),
 
     [FDI1] = couch_db_engine:open_docs(Db2, [<<"foo">>]),
-    PrevRev1 = test_engine_util:prev_rev(FDI1),
+    PrevRev1 = cpse_util:prev_rev(FDI1),
     Rev1 = PrevRev1#rev_info.rev,
 
     Actions2 = [
         {purge, {<<"foo">>, Rev1}}
     ],
-    {ok, Db3} = test_engine_util:apply_actions(Db2, Actions2),
+    {ok, Db3} = cpse_util:apply_actions(Db2, Actions2),
 
     ?assertEqual(1, couch_db_engine:get_doc_count(Db3)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db3)),
@@ -79,13 +79,13 @@ cet_purge_conflicts() ->
     ?assertEqual([{<<"foo">>, [Rev1]}], couch_db_engine:get_last_purged(Db3)),
 
     [FDI2] = couch_db_engine:open_docs(Db3, [<<"foo">>]),
-    PrevRev2 = test_engine_util:prev_rev(FDI2),
+    PrevRev2 = cpse_util:prev_rev(FDI2),
     Rev2 = PrevRev2#rev_info.rev,
 
     Actions3 = [
         {purge, {<<"foo">>, Rev2}}
     ],
-    {ok, Db4} = test_engine_util:apply_actions(Db3, Actions3),
+    {ok, Db4} = cpse_util:apply_actions(Db3, Actions3),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db4)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db4)),
@@ -95,14 +95,14 @@ cet_purge_conflicts() ->
 
 
 cet_add_delete_purge() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     Actions1 = [
         {create, {<<"foo">>, {[{<<"vsn">>, 1}]}}},
         {delete, {<<"foo">>, {[{<<"vsn">>, 2}]}}}
     ],
 
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions1),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions1),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db2)),
     ?assertEqual(1, couch_db_engine:get_del_doc_count(Db2)),
@@ -111,13 +111,13 @@ cet_add_delete_purge() ->
     ?assertEqual([], couch_db_engine:get_last_purged(Db2)),
 
     [FDI] = couch_db_engine:open_docs(Db2, [<<"foo">>]),
-    PrevRev = test_engine_util:prev_rev(FDI),
+    PrevRev = cpse_util:prev_rev(FDI),
     Rev = PrevRev#rev_info.rev,
 
     Actions2 = [
         {purge, {<<"foo">>, Rev}}
     ],
-    {ok, Db3} = test_engine_util:apply_actions(Db2, Actions2),
+    {ok, Db3} = cpse_util:apply_actions(Db2, Actions2),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db3)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db3)),
@@ -127,14 +127,14 @@ cet_add_delete_purge() ->
 
 
 cet_add_two_purge_one() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     Actions1 = [
         {create, {<<"foo">>, {[{<<"vsn">>, 1}]}}},
         {create, {<<"bar">>, {[]}}}
     ],
 
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions1),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions1),
 
     ?assertEqual(2, couch_db_engine:get_doc_count(Db2)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db2)),
@@ -143,13 +143,13 @@ cet_add_two_purge_one() ->
     ?assertEqual([], couch_db_engine:get_last_purged(Db2)),
 
     [FDI] = couch_db_engine:open_docs(Db2, [<<"foo">>]),
-    PrevRev = test_engine_util:prev_rev(FDI),
+    PrevRev = cpse_util:prev_rev(FDI),
     Rev = PrevRev#rev_info.rev,
 
     Actions2 = [
         {purge, {<<"foo">>, Rev}}
     ],
-    {ok, Db3} = test_engine_util:apply_actions(Db2, Actions2),
+    {ok, Db3} = cpse_util:apply_actions(Db2, Actions2),
 
     ?assertEqual(1, couch_db_engine:get_doc_count(Db3)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db3)),
diff --git a/src/couch_pse_tests/src/cpse_test_read_write_docs.erl b/src/couch_pse_tests/src/cpse_test_read_write_docs.erl
index 1f20c4076..907f5d92d 100644
--- a/src/couch_pse_tests/src/cpse_test_read_write_docs.erl
+++ b/src/couch_pse_tests/src/cpse_test_read_write_docs.erl
@@ -19,7 +19,7 @@
 
 
 cet_read_empty_docs() ->
-    {ok, Db} = test_engine_util:create_db(),
+    {ok, Db} = cpse_util:create_db(),
 
     ?assertEqual([not_found], couch_db_engine:open_docs(Db, [<<"foo">>])),
     ?assertEqual(
@@ -29,7 +29,7 @@ cet_read_empty_docs() ->
 
 
 cet_read_empty_local_docs() ->
-    {ok, Db} = test_engine_util:create_db(),
+    {ok, Db} = cpse_util:create_db(),
 
     {LocalA, LocalB} = {<<"_local/a">>, <<"_local/b">>},
     ?assertEqual([not_found], couch_db_engine:open_local_docs(Db, [LocalA])),
@@ -40,7 +40,7 @@ cet_read_empty_local_docs() ->
 
 
 cet_write_one_doc() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db1)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db1)),
@@ -49,11 +49,11 @@ cet_write_one_doc() ->
     Actions = [
         {create, {<<"foo">>, {[{<<"vsn">>, 1}]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
     ?assertEqual(1, couch_db_engine:get_doc_count(Db2)),
 
     {ok, _} = couch_db:ensure_full_commit(Db2),
-    test_engine_util:shutdown_db(Db2),
+    cpse_util:shutdown_db(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
 
@@ -66,7 +66,7 @@ cet_write_one_doc() ->
         rev = {RevPos, PrevRevId},
         deleted = Deleted,
         body_sp = DocPtr
-    } = test_engine_util:prev_rev(FDI),
+    } = cpse_util:prev_rev(FDI),
 
     Doc0 = #doc{
         id = <<"foo">>,
@@ -83,7 +83,7 @@ cet_write_one_doc() ->
 
 
 cet_write_two_docs() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db1)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db1)),
@@ -93,9 +93,9 @@ cet_write_two_docs() ->
         {create, {<<"foo">>, {[{<<"vsn">>, 1}]}}},
         {create, {<<"bar">>, {[{<<"stuff">>, true}]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
     {ok, _} = couch_db:ensure_full_commit(Db2),
-    test_engine_util:shutdown_db(Db2),
+    cpse_util:shutdown_db(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
 
@@ -108,7 +108,7 @@ cet_write_two_docs() ->
 
 
 cet_write_three_doc_batch() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db1)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db1)),
@@ -121,9 +121,9 @@ cet_write_three_doc_batch() ->
             {create, {<<"baz">>, {[]}}}
         ]}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
     {ok, _} = couch_db:ensure_full_commit(Db2),
-    test_engine_util:shutdown_db(Db2),
+    cpse_util:shutdown_db(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
 
@@ -136,7 +136,7 @@ cet_write_three_doc_batch() ->
 
 
 cet_update_doc() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db1)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db1)),
@@ -146,9 +146,9 @@ cet_update_doc() ->
         {create, {<<"foo">>, {[{<<"vsn">>, 1}]}}},
         {update, {<<"foo">>, {[{<<"vsn">>, 2}]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
     {ok, _} = couch_db:ensure_full_commit(Db2),
-    test_engine_util:shutdown_db(Db2),
+    cpse_util:shutdown_db(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
 
@@ -162,7 +162,7 @@ cet_update_doc() ->
         rev = {RevPos, PrevRevId},
         deleted = Deleted,
         body_sp = DocPtr
-    } = test_engine_util:prev_rev(FDI),
+    } = cpse_util:prev_rev(FDI),
 
     Doc0 = #doc{
         id = <<"foo">>,
@@ -180,7 +180,7 @@ cet_update_doc() ->
 
 
 cet_delete_doc() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db1)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db1)),
@@ -190,9 +190,9 @@ cet_delete_doc() ->
         {create, {<<"foo">>, {[{<<"vsn">>, 1}]}}},
         {delete, {<<"foo">>, {[]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
     {ok, _} = couch_db:ensure_full_commit(Db2),
-    test_engine_util:shutdown_db(Db2),
+    cpse_util:shutdown_db(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
     ?assertEqual(0, couch_db_engine:get_doc_count(Db3)),
@@ -205,7 +205,7 @@ cet_delete_doc() ->
         rev = {RevPos, PrevRevId},
         deleted = Deleted,
         body_sp = DocPtr
-    } = test_engine_util:prev_rev(FDI),
+    } = cpse_util:prev_rev(FDI),
 
     Doc0 = #doc{
         id = <<"foo">>,
@@ -223,7 +223,7 @@ cet_delete_doc() ->
 
 
 cet_write_local_doc() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db1)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db1)),
@@ -232,9 +232,9 @@ cet_write_local_doc() ->
     Actions = [
         {create, {<<"_local/foo">>, {[{<<"yay">>, false}]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
     {ok, _} = couch_db:ensure_full_commit(Db2),
-    test_engine_util:shutdown_db(Db2),
+    cpse_util:shutdown_db(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
 
@@ -248,7 +248,7 @@ cet_write_local_doc() ->
 
 
 cet_write_mixed_batch() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db1)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db1)),
@@ -260,9 +260,9 @@ cet_write_mixed_batch() ->
             {create, {<<"_local/foo">>, {[{<<"yay">>, false}]}}}
         ]}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
     {ok, _} = couch_db:ensure_full_commit(Db2),
-    test_engine_util:shutdown_db(Db2),
+    cpse_util:shutdown_db(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
 
@@ -278,7 +278,7 @@ cet_write_mixed_batch() ->
 
 
 cet_update_local_doc() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db1)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db1)),
@@ -288,9 +288,9 @@ cet_update_local_doc() ->
         {create, {<<"_local/foo">>, {[]}}},
         {update, {<<"_local/foo">>, {[{<<"stuff">>, null}]}}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
     {ok, _} = couch_db:ensure_full_commit(Db1),
-    test_engine_util:shutdown_db(Db2),
+    cpse_util:shutdown_db(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
 
@@ -304,7 +304,7 @@ cet_update_local_doc() ->
 
 
 cet_delete_local_doc() ->
-    {ok, Db1} = test_engine_util:create_db(),
+    {ok, Db1} = cpse_util:create_db(),
 
     ?assertEqual(0, couch_db_engine:get_doc_count(Db1)),
     ?assertEqual(0, couch_db_engine:get_del_doc_count(Db1)),
@@ -314,9 +314,9 @@ cet_delete_local_doc() ->
         {create, {<<"_local/foo">>, []}},
         {delete, {<<"_local/foo">>, []}}
     ],
-    {ok, Db2} = test_engine_util:apply_actions(Db1, Actions),
+    {ok, Db2} = cpse_util:apply_actions(Db1, Actions),
     {ok, _} = couch_db:ensure_full_commit(Db2),
-    test_engine_util:shutdown_db(Db2),
+    cpse_util:shutdown_db(Db2),
 
     {ok, Db3} = couch_db:reopen(Db2),
 
diff --git a/src/couch_pse_tests/src/cpse_test_ref_counting.erl b/src/couch_pse_tests/src/cpse_test_ref_counting.erl
index c21ec88b6..552904940 100644
--- a/src/couch_pse_tests/src/cpse_test_ref_counting.erl
+++ b/src/couch_pse_tests/src/cpse_test_ref_counting.erl
@@ -22,7 +22,7 @@
 
 
 cet_empty_monitors() ->
-    {ok, Db} = test_engine_util:create_db(),
+    {ok, Db} = cpse_util:create_db(),
     Pids = couch_db_engine:monitored_by(Db),
     ?assert(is_list(Pids)),
     Expected = [
@@ -34,7 +34,7 @@ cet_empty_monitors() ->
 
 
 cet_incref_decref() ->
-    {ok, Db} = test_engine_util:create_db(),
+    {ok, Db} = cpse_util:create_db(),
 
     {Pid, _} = Client = start_client(Db),
     wait_client(Client),
@@ -49,7 +49,7 @@ cet_incref_decref() ->
 
 
 cet_incref_decref_many() ->
-    {ok, Db} = test_engine_util:create_db(),
+    {ok, Db} = cpse_util:create_db(),
     Clients = lists:map(fun(_) ->
         start_client(Db)
     end, lists:seq(1, ?NUM_CLIENTS)),