Adjust to mongoose_helper:wait_until/3

Author: zofpolkowska

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}),
@@ -878,13 +878,15 @@ 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)
+                                 time_sleep => timer:seconds(1),
+                                 name => is_session_alive
                                 }).
 
 wait_for_handler(Pid) ->
     mongoose_helper:wait_until(fun() -> length(get_handlers(Pid)) end, 1, #{
                                                                             time_left => timer:seconds(10),
-                                                                            time_sleep => timer:seconds(1)
+                                                                            time_sleep => timer:seconds(1),
+                                                                            name => get_handlers
                                                                            }).
 
 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, true).
+    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

@@ -794,29 +794,38 @@ wait_for_archive_size(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)}).
+                               #{
+                                 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)}) of
+                                   ExpectedSize,
+                                   #{
+                                     time_left => timer:seconds(20),
+                                     name => archive_size
+                                    }) of
         {ok, ExpectedSize} ->
             ok
     catch
-        Error:Reason ->
+        _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, ExpectedSize) ->
     try mongoose_helper:wait_until(fun() -> room_archive_size(Server, Username) end,
                                    ExpectedSize,
-                                   #{time_left => timer:seconds(20)}) of
+                                   #{
+                                     time_left => timer:seconds(20),
+                                     name => room_archive_size
+                                    }) of
         {ok, ExpectedSize} ->
             ExpectedSize
     catch
-        Error:Reason ->
-            ct:pal("issue=wait_for_archive_size_or_warning, expected_size=~p, log=~p",
+        _Error:Reason ->
+            ct:pal("issue=wait_for_room_archive_size, expected_size=~p, log=~p",
                    [ExpectedSize, Reason])
     end.
 

big_tests/tests/metrics_register_SUITE.erl

@@ -109,8 +109,10 @@ unregister(Config) ->
 
 wait_for_registrations(Count) ->
     mongoose_helper:wait_until(fun() -> assert_counter(Count, modRegisterCount) end,
-                               {value, Count}).
+                               {value, Count},
+                               #{name => assert_counter}).
 
 wait_for_deregistrations(Count) ->
     mongoose_helper:wait_until(fun() -> assert_counter(Count, modUnregisterCount) end,
-                               {value, Count}).
+                               {value, Count},
+                               #{name => assert_counter}).

big_tests/tests/mod_global_distrib_SUITE.erl

@@ -300,7 +300,7 @@ unpause_refresher(NodeName, _) ->
 %% for each host in get_hosts().
 %% Reads Redis to confirm that endpoints (in Redis) are overwritten
 %% with `advertised_endpoints` option value
-test_advertised_endpoints_override_endpoints(Config) ->
+test_advertised_endpoints_override_endpoints(_Config) ->
     Endps = execute_on_each_node(mod_global_distrib_mapping_redis,
                                  get_endpoints,
                                  [<<"reg1">>]),
@@ -313,13 +313,15 @@ test_advertised_endpoints_override_endpoints(Config) ->
 %% Also actually verifies that refresher properly reads host list
 %% from backend and starts appropriate pool.
 test_host_refreshing(_Config) ->
-    mongoose_helper:wait_until(fun() -> trees_for_connections_present() end, true),
+    mongoose_helper:wait_until(fun() -> trees_for_connections_present() end, true,
+                               #{name => trees_for_connections_present}),
     ConnectionSups = out_connection_sups(asia_node),
     {europe_node1, EuropeHost, _} = lists:keyfind(europe_node1, 1, get_hosts()),
     EuropeSup = rpc(asia_node, mod_global_distrib_utils, server_to_sup_name, [list_to_binary(EuropeHost)]),
     {_, EuropePid, supervisor, _} = lists:keyfind(EuropeSup, 1, ConnectionSups),
     erlang:exit(EuropePid, kill), % it's ok to kill temporary process
-    mongoose_helper:wait_until(fun() -> tree_for_sup_present(asia_node, EuropeSup) end, true).
+    mongoose_helper:wait_until(fun() -> tree_for_sup_present(asia_node, EuropeSup) end, true,
+                               #{name => tree_for_sup_present}).
 
 %% When run in mod_global_distrib group - tests simple case of connection
 %% between two users connected to different clusters.
@@ -731,14 +733,8 @@ test_update_senders_host(Config) ->
               AliceJid = rpc(asia_node, jid, from_binary, [escalus_client:full_jid(Alice)]),
               {ok, <<"localhost.bis">>}
               = rpc(asia_node, mod_global_distrib_mapping, for_jid, [AliceJid]),
-
               ok = rpc(europe_node1, mod_global_distrib_mapping, delete_for_jid, [AliceJid]),
-              GetCachesFun
-              = fun() ->
-                        rpc(asia_node, mod_global_distrib_mapping, for_jid, [AliceJid])
-                end,
-              mongoose_helper:wait_until(GetCachesFun, error, #{time_left => timer:seconds(10),
-                                                                sleep_time => timer:seconds(1)}),
+              wait_for_node(asia_node, AliceJid),
 
               %% TODO: Should prevent Redis refresher from executing for a moment,
               %%       as it may collide with this test.
@@ -749,6 +745,12 @@ test_update_senders_host(Config) ->
               {ok, <<"localhost.bis">>}
               = rpc(asia_node, mod_global_distrib_mapping, for_jid, [AliceJid])
       end).
+wait_for_node(Node,Jid) ->
+    mongoose_helper:wait_until(fun() -> rpc(Node, mod_global_distrib_mapping, for_jid, [Jid]) end,
+                               error,
+                               #{time_left => timer:seconds(10),
+                                 sleep_time => timer:seconds(1),
+                                 name => rpc}).
 
 test_update_senders_host_by_ejd_service(Config) ->
     %% Connects to europe_node1
@@ -766,16 +768,8 @@ test_update_senders_host_by_ejd_service(Config) ->
               {ok, <<"reg1">>} = rpc(europe_node2, mod_global_distrib_mapping, for_jid, [EveJid]),
 
               ok = rpc(asia_node, mod_global_distrib_mapping, delete_for_jid, [EveJid]),
-              GetCachesFun
-              = fun() ->
-                        {
-                         rpc(europe_node1, mod_global_distrib_mapping, for_jid, [EveJid]),
-                         rpc(europe_node2, mod_global_distrib_mapping, for_jid, [EveJid])
-                        }
-                end,
-              mongoose_helper:wait_until(GetCachesFun, {error, error},
-                                         #{time_left => timer:seconds(10),
-                                           sleep_time => timer:seconds(1)}),
+              wait_for_node(europe_node1, EveJid),
+              wait_for_node(europe_node2, EveJid),
 
               %% Component is connected to europe_node1
               %% but we force asia_node to connect to europe_node2 by hiding europe_node1
@@ -875,7 +869,9 @@ closed_connection_is_removed_from_disabled(_Config) ->
     % Will drop connections and prevent them from reconnecting
     restart_receiver(asia_node, [listen_endpoint(10001)]),
 
-    mongoose_helper:wait_until(fun() -> get_outgoing_connections(europe_node1, <<"reg1">>) end, {[], [], []}).
+    mongoose_helper:wait_until(fun() -> get_outgoing_connections(europe_node1, <<"reg1">>) end,
+                               {[], [], []},
+                              #{name => get_outgoing_connections}).
 
 %%--------------------------------------------------------------------
 %% Test helpers
@@ -1023,7 +1019,7 @@ mock_inet() ->
     meck:expect(inet, getaddrs, fun(_, inet) -> {ok, [{127, 0, 0, 1}]};
                                    (_, inet6) -> {error, "No ipv6 address"} end).
 
-unmock_inet(Pids) ->
+unmock_inet(_Pids) ->
     execute_on_each_node(meck, unload, [inet]).
 
 out_connection_sups(Node) ->

big_tests/tests/muc_SUITE.erl

@@ -4339,7 +4339,7 @@ wait_for_room_to_be_stopped(Pid, Timeout) ->
     end.
 
 wait_for_hibernation(Pid) ->
-    mongoose_helper:wait_until(fun() -> is_hibernated(Pid) end, true).
+    mongoose_helper:wait_until(fun() -> is_hibernated(Pid) end, true, #{name => is_hibernated}).
 
 is_hibernated(Pid) ->
     CurrentFunction = rpc(mim(), erlang, process_info, [Pid, current_function]),

big_tests/tests/push_helper.erl

@@ -80,5 +80,5 @@ wait_for_user_offline(Client) ->
                                                   escalus_utils:jid_to_lower(escalus_client:server(Client)),
                                                   escalus_utils:jid_to_lower(escalus_client:resource(Client)))
                                end,
-                              true,
-                              #{time_left => timer:seconds(20)}).
+                               true,
+                               #{time_left => timer:seconds(20), name => is_offline}).

big_tests/tests/sm_SUITE.erl

@@ -834,7 +834,8 @@ extract_state_name(SysStatus) ->
     proplists:get_value("StateName", FSMData).
 
 wait_until_disconnected(UserSpec) ->
-    mongoose_helper:wait_until(fun() -> get_user_resources(UserSpec) =:= [] end, true).
+    mongoose_helper:wait_until(fun() -> get_user_resources(UserSpec) =:= [] end, true,
+                               #{name => get_user_resources}).
 
 get_session_pid(UserSpec, Resource) ->
     {U, S} = get_us_from_spec(UserSpec),

big_tests/tests/users_api_SUITE.erl

@@ -103,6 +103,12 @@ wait_for_user_removal(false) ->
     ok;
 wait_for_user_removal(_) ->
     Domain = ct:get_config({hosts, mim, domain}),
-    mongoose_helper:wait_until(fun() -> rpc(mim(), ejabberd_auth_riak, get_vh_registered_users_number, [Domain]) end,
-                              0,
-			      #{ time_sleep => 500, time_left => 5000}).
+    try mongoose_helper:wait_until(fun() -> rpc(mim(), ejabberd_auth_riak, get_vh_registered_users_number, [Domain]) end, 0,
+                               #{ time_sleep => 500, time_left => 5000, name => rpc}) of
+	    {ok, 0} ->
+		    ok
+    catch	
+	_Error:Reason ->
+		ct:pal("~p", [Reason]),
+		ok
+    end.