Merge pull request #1962 from esl/incremental-sleep-redundancy

Incremental sleep redundancy

Author: michalwski

big_tests/tests/bosh_SUITE.erl

@@ -189,7 +189,7 @@ do_not_accept_0_hold_value(Config) ->
 send_specific_hold(Config, HoldValue) ->
     {Server, Path, Client} = get_fusco_connection(Config),
 
-    Rid = random:uniform(1000000),
+    Rid = rand:uniform(1000000),
     Body0 = escalus_bosh:session_creation_body(2, <<"1.0">>, <<"en">>, Rid, Server, nil),
     #xmlel{attrs = Attrs0} = Body0,
     Attrs = lists:keyreplace(<<"hold">>, 1, Attrs0, {<<"hold">>, HoldValue}),
@@ -379,7 +379,7 @@ cant_send_invalid_rid(Config) ->
 
         escalus:assert(is_stream_end, escalus:wait_for_stanza(Carol)),
         escalus_client:wait_for_close(Config, Carol, timer:seconds(1)),
-        true = wait_for_session_close(Sid, 10)
+        {ok, false} = wait_for_session_close(Sid)
 
         end).
 
@@ -464,7 +464,7 @@ disconnect_inactive(Config) ->
         timer:sleep(2 * timer:seconds(?INACTIVITY)),
 
         %% Assert Carol has been disconnected due to inactivity.
-        false = is_sesssion_alive(Sid),
+        false = is_session_alive(Sid),
 
         %% We don't need to close the session in escalus_bosh:stop/1
         escalus_client:kill_connection(Config, Carol)
@@ -486,7 +486,7 @@ connection_interrupted(Config) ->
 
         %% Assert Carol has not been disconnected yet.
         timer:sleep(100),
-        true = is_sesssion_alive(Sid),
+        true = is_session_alive(Sid),
 
         %% Wait for disconnection because of inactivity timeout.
         %% Keep in mind this only works due to the max_wait also being lowered.
@@ -495,7 +495,7 @@ connection_interrupted(Config) ->
         timer:sleep(timer:seconds(?INACTIVITY) + timer:seconds(?MAX_WAIT)),
 
         %% Assert Carol has been disconnected due to inactivity.
-        false = is_sesssion_alive(Sid)
+        false = is_session_alive(Sid)
 
         end).
 
@@ -510,7 +510,7 @@ interrupt_long_poll_is_activity(ConfigIn) ->
         %% to Carol and one handler for Carol.
         Sid = get_bosh_sid(Carol),
         {_, _, CarolSessionPid} = get_bosh_session(Sid),
-        1 = wait_for_handler(CarolSessionPid),
+        {ok, 1} = wait_for_handler(CarolSessionPid),
 
         %% Send a message.  A new connection should be established, and
         %% the existing long-poll connection should be closed.
@@ -523,8 +523,8 @@ interrupt_long_poll_is_activity(ConfigIn) ->
 
         %% No disconnection should have occurred.
         escalus_assert:has_no_stanzas(Carol),
-        true = is_sesssion_alive(Sid),
-        1 = wait_for_handler(CarolSessionPid)
+        true = is_session_alive(Sid),
+        {ok, 1} = wait_for_handler(CarolSessionPid)
 
         end).
 
@@ -536,13 +536,13 @@ reply_on_pause(Config) ->
         set_keepalive(Carol, false),
 
         %% Sanity check - there should be one handler for Carol.
-        1 = wait_for_handler(CarolSessionPid),
+        {ok, 1} = wait_for_handler(CarolSessionPid),
 
         pause(Carol, 10),
 
         %% There should be no handlers for Carol,
         %% but the session should be alive.
-        true = is_sesssion_alive(Sid),
+        true = is_session_alive(Sid),
         0 = length(get_handlers(CarolSessionPid)),
         0 = get_bosh_requests(Carol)
 
@@ -556,13 +556,13 @@ cant_pause_for_too_long(Config) ->
         set_keepalive(Carol, false),
 
         %% Sanity check - there should be one handler for Carol.
-        1 = wait_for_handler(CarolSessionPid),
+        {ok, 1} = wait_for_handler(CarolSessionPid),
 
         pause(Carol, 10000),
 
         escalus:assert(is_stream_end, escalus:wait_for_stanza(Carol)),
         escalus_client:wait_for_close(Config, Carol, timer:seconds(1)),
-        false = is_sesssion_alive(Sid)
+        false = is_session_alive(Sid)
 
         end).
 
@@ -575,7 +575,7 @@ pause_request_is_activity(Config) ->
         set_keepalive(Carol, false),
 
         %% Sanity check - there should be one handler for Carol.
-        1 = wait_for_handler(CarolSessionPid),
+        {ok, 1} = wait_for_handler(CarolSessionPid),
 
         %% Wait most of the allowed inactivity interval.
         timer:sleep(timer:seconds(?INACTIVITY - 1)),
@@ -588,7 +588,7 @@ pause_request_is_activity(Config) ->
 
         %% No disconnection should've occured.
         escalus_assert:has_no_stanzas(Carol),
-        true = is_sesssion_alive(Sid)
+        true = is_session_alive(Sid)
 
         end).
 
@@ -618,7 +618,7 @@ reply_in_time(ConfigIn) ->
         Empty = escalus_bosh:empty_body(Rid, Sid),
         bosh_send_raw(Carol, Empty),
         timer:sleep(100),
-        1 = wait_for_handler(CarolSessionPid),
+        {ok, 1} = wait_for_handler(CarolSessionPid),
 
         timer:sleep(timer:seconds(Wait) + 100),
 
@@ -870,34 +870,24 @@ server_acks_opt() ->
      fun(V) -> rpc(mim(), mod_bosh, set_server_acks, [V]) end,
      true}.
 
-is_sesssion_alive(Sid) ->
+is_session_alive(Sid) ->
     BoshSessions = get_bosh_sessions(),
     lists:keymember(Sid, 2, BoshSessions).
 
-wait_for_session_close(Sid, 0) ->
-    false == is_sesssion_alive(Sid);
-wait_for_session_close(Sid, N) ->
-    case is_sesssion_alive(Sid) of
-        false ->
-            true;
-        _ ->
-            timer:sleep(100),
-            wait_for_session_close(Sid, N-1)
-    end.
+wait_for_session_close(Sid) ->
+    mongoose_helper:wait_until(fun() -> is_session_alive(Sid) end, false,
+                               #{
+                                 time_left => timer:seconds(10),
+                                 time_sleep => timer:seconds(1),
+                                 name => is_session_alive
+                                }).
 
 wait_for_handler(Pid) ->
-    wait_for_handler(Pid, 10).
-
-wait_for_handler(Pid, 0) ->
-    length(get_handlers(Pid));
-wait_for_handler(Pid, N) ->
-    case get_handlers(Pid) of
-        [] ->
-            timer:sleep(50),
-            wait_for_handler(Pid, N-1);
-        L ->
-            length(L)
-    end.
+    mongoose_helper:wait_until(fun() -> length(get_handlers(Pid)) end, 1, #{
+                                                                            time_left => timer:seconds(10),
+                                                                            time_sleep => timer:seconds(1),
+                                                                            name => get_handlers
+                                                                           }).
 
 domain() ->
     ct:get_config({hosts, mim, domain}).

big_tests/tests/component_helper.erl

@@ -44,7 +44,8 @@ disconnect_component(Component, Addr) ->
 disconnect_components(Components, Addr) ->
     %% TODO replace 'kill' with 'stop' when server supports stream closing
     [escalus_connection:kill(Component) || Component <- Components],
-    mongoose_helper:wait_until(fun() -> rpc(ejabberd_router, lookup_component, [Addr]) =:= [] end, 5, 200).
+    mongoose_helper:wait_until(fun() -> rpc(ejabberd_router, lookup_component, [Addr]) =:= [] end, true,
+                               #{name => rpc}).
 
 rpc(M, F, A) ->
     Node = ct:get_config({hosts, mim, node}),

big_tests/tests/mam_helper.erl

@@ -17,8 +17,6 @@
 
 -compile(export_all).
 
--export([wait_for_complete_archive_response/3]).
-
 -include("mam_helper.hrl").
 -include_lib("escalus/include/escalus.hrl").
 -include_lib("escalus/include/escalus_xmlns.hrl").
@@ -764,8 +762,8 @@ clean_archives(Config) ->
     %% It is not the best place to delete these messages.
     [ok = delete_offline_messages(S, U) || {S, U} <- SUs],
     [ok = delete_archive(S, U) || {S, U} <- SUs],
-    %% Retry 10 times if not empty
-    [assert_empty_archive(S, U, 10) || {S, U} <- SUs],
+    %% Wait for archive to be empty
+    [wait_for_archive_size(S, U, 0) || {S, U} <- SUs],
     Config.
 
 destroy_room(Config) ->
@@ -776,7 +774,7 @@ clean_room_archive(Config) ->
     Room = ?config(room, Config),
     delete_room_archive(muc_host(), Room),
     %% Retry 10 times if not empty
-    assert_empty_room_archive(muc_host(), Room, 10),
+    wait_for_room_archive_size(muc_host(), Room, 0),
     Config.
 
 serv_users(Config) ->
@@ -787,63 +785,48 @@ serv_user(Config, UserSpec) ->
     [Username, Server, _Pass] = escalus_users:get_usp(Config, UserSpec),
     {Server, Username}.
 
-%% @doc Check, that the archive is empty.
-assert_empty_archive(Server, Username, RetryTimes) when is_integer(RetryTimes) ->
-    %% Wait for zero messages in archive
-    case wait_for_archive_size(Server, Username, RetryTimes, 0) of
-       0 -> ok;
-       X -> ct:fail({not_empty, Server, Username, {actual_size, X}})
-    end.
-
 wait_for_archive_size(User, ExpectedSize) ->
-    Server = escalus_utils:get_server(User),
-    Username = escalus_utils:jid_to_lower(escalus_utils:get_username(User)),
-    case wait_for_archive_size(Server, Username, 100, ExpectedSize) of
-		ExpectedSize ->
-			ok;
-		ArchiveSize ->
-			ct:fail({expected_archive_size, Username, Server, ExpectedSize,
-					 {actual_size, ArchiveSize}})
-	end.
-
-wait_for_archive_size(Server, Username, _RetryTimes=0, _ExpectedSize) ->
-    archive_size(Server, Username);
-wait_for_archive_size(Server, Username, RetryTimes, ExpectedSize) when RetryTimes > 0 ->
-    case archive_size(Server, Username) of
-        ExpectedSize ->
-            ExpectedSize;
-        _ActualSize ->
-            %% Wait and retry
-            timer:sleep(100),
-            wait_for_archive_size(Server, Username, RetryTimes-1, ExpectedSize)
-    end.
-
-wait_for_archive_size_or_warning(Server, Username, RetryTimes, ExpectedSize) ->
-    case wait_for_archive_size(Server, Username, RetryTimes, ExpectedSize) of
-        ExpectedSize -> ok;
-        ActualSize ->
-            ct:pal("issue=wait_for_archive_size_or_warning, expected_size=~p, actual_size=~p",
-                   [ExpectedSize, ActualSize])
-    end.
-
-%% @doc Check, that the archive is empty.
-assert_empty_room_archive(Server, Username, RetryTimes) ->
-    %% Wait for zero messages in archive
-    case wait_for_room_archive_size(Server, Username, RetryTimes, 0) of
-       0 -> ok;
-       X -> ct:fail({room_not_empty, Server, Username, {actual_size, X}})
+    wait_for_archive_size(
+      escalus_utils:get_server(User),
+      escalus_utils:jid_to_lower(escalus_utils:get_username(User)),
+      ExpectedSize).
+
+wait_for_archive_size(Server, Username, ExpectedSize) ->
+    mongoose_helper:wait_until(fun() -> archive_size(Server, Username) end,
+                               ExpectedSize,
+                               #{
+                                 time_left => timer:seconds(20),
+                                 name => archive_size
+                                }).
+
+wait_for_archive_size_or_warning(Server, Username, ExpectedSize) ->
+    try mongoose_helper:wait_until(fun() -> archive_size(Server, Username) end,
+                                   ExpectedSize,
+                                   #{
+                                     time_left => timer:seconds(20),
+                                     name => archive_size
+                                    }) of
+        {ok, ExpectedSize} ->
+            ok
+    catch
+        _Error:Reason ->
+            ct:pal("issue=wait_for_archive_size_or_warning, expected_size=~p, log=~p",
+                   [ExpectedSize, Reason])
     end.
 
-wait_for_room_archive_size(Server, Username, _RetryTimes=0, _ExpectedSize) ->
-    room_archive_size(Server, Username);
-wait_for_room_archive_size(Server, Username, RetryTimes, ExpectedSize) when RetryTimes > 0 ->
-    case room_archive_size(Server, Username) of
-        ExpectedSize ->
-            ExpectedSize;
-        _ActualSize ->
-            %% Wait and retry
-            timer:sleep(100),
-            wait_for_room_archive_size(Server, Username, RetryTimes-1, ExpectedSize)
+wait_for_room_archive_size(Server, Username, ExpectedSize) ->
+    try mongoose_helper:wait_until(fun() -> room_archive_size(Server, Username) end,
+                                   ExpectedSize,
+                                   #{
+                                     time_left => timer:seconds(20),
+                                     name => room_archive_size
+                                    }) of
+        {ok, ExpectedSize} ->
+            ExpectedSize
+    catch
+        _Error:Reason ->
+            ct:pal("issue=wait_for_room_archive_size, expected_size=~p, log=~p",
+                   [ExpectedSize, Reason])
     end.
 
 
@@ -943,7 +926,7 @@ bootstrap_archive(Config) ->
 %% Wait for messages to be written
 wait_for_msgs(Msgs, Users) ->
     UsersCnt = [{S, U, count_msgs(Msgs, S, U)} || {S, U} <- Users],
-    [wait_for_archive_size_or_warning(S, U, 20, C) || {S, U, C} <- UsersCnt],
+    [wait_for_archive_size_or_warning(S, U, C) || {S, U, C} <- UsersCnt],
     ok.
 
 count_msgs(Msgs, S, U) ->
@@ -1039,7 +1022,7 @@ muc_bootstrap_archive(Config) ->
 
     maybe_wait_for_archive(Config),
     ?assert_equal(length(Msgs),
-                  wait_for_room_archive_size(Domain, Room, 10, length(Msgs))),
+                  wait_for_room_archive_size(Domain, Room, length(Msgs))),
 
     [{pre_generated_muc_msgs, sort_msgs(Msgs)} | Config].
 

big_tests/tests/metrics_register_SUITE.erl

@@ -30,7 +30,6 @@
 -import(metrics_helper, [assert_counter/2,
                          get_counter_value/1]).
 
--import(mongoose_helper, [factor_backoff/3]).
 
 %%--------------------------------------------------------------------
 %% Suite configuration
@@ -91,32 +90,29 @@ end_per_testcase(_CaseName, Config) ->
 %%--------------------------------------------------------------------
 
 register(Config) ->
-    {value, Registarations} = get_counter_value(modRegisterCount),
+    {value, Registrations} = get_counter_value(modRegisterCount),
 
     Alice = escalus_users:get_user_by_name(alice),
     escalus_users:create_user(Config, Alice),
-
-    factor_backoff(fun() -> assert_counter(Registarations + 1, modRegisterCount) end,
-                   {value, Registarations + 1},
-                   #{
-                             attempts => 10,
-                             min_time => 30,
-                             max_time => 150
-                            }
-                  ).
-
+    wait_for_registrations(Registrations + 1).
 
 unregister(Config) ->
-    {value, Deregistarations} = get_counter_value(modUnregisterCount),
+    {value, Deregistrations} = get_counter_value(modUnregisterCount),
 
     Alice = escalus_users:get_user_by_name(alice),
     escalus_users:delete_user(Config, Alice),
+    wait_for_deregistrations(Deregistrations + 1).
+
+%%--------------------------------------------------------------------
+%% Helpers
+%%--------------------------------------------------------------------
+
+wait_for_registrations(Count) ->
+    mongoose_helper:wait_until(fun() -> assert_counter(Count, modRegisterCount) end,
+                               {value, Count},
+                               #{name => assert_counter}).
 
-    factor_backoff(fun() -> assert_counter(Deregistarations + 1, modUnregisterCount) end,
-                   {value, Deregistarations + 1},
-                   #{
-                             attempts => 10,
-                             min_time => 30,
-                             max_time => 150
-                            }
-                  ).
+wait_for_deregistrations(Count) ->
+    mongoose_helper:wait_until(fun() -> assert_counter(Count, modUnregisterCount) end,
+                               {value, Count},
+                               #{name => assert_counter}).