WIP

big_tests/tests/instrument_helper.erl

@@ -10,6 +10,8 @@
 -export([assert/3, assert_one/3, assert_not_emitted/3, assert_not_emitted/2, assert_not_emitted/1,
          wait_and_assert/3, wait_and_assert_new/3, assert/4]).
 
+-export([timestamp/0]).
+
 -import(distributed_helper, [rpc/4, mim/0]).
 
 -include_lib("eunit/include/eunit.hrl").

big_tests/tests/mam_SUITE.erl

@@ -3286,7 +3286,7 @@ prefs_set_request(Config) ->
         ?assert_equal(ResultIQ1, ResultIQ2),
         ok
         end,
-    escalus:story(Config, [{alice, 1}], F).
+    escalus:fresh_story(Config, [{alice, 1}], F).
 
 query_get_request(Config) ->
     F = fun(Alice) ->

big_tests/tests/mod_blocking_SUITE.erl

@@ -231,12 +231,13 @@ messages_from_blocked_user_dont_arrive(Config) ->
         Config, [{alice, 1}, {bob, 1}],
         fun(User1, User2) ->
             user_blocks(User1, [User2]),
+            TS = instrument_helper:timestamp(),
             message(User2, User1, <<"Hi!">>),
             ct:sleep(100),
             escalus_assert:has_no_stanzas(User1),
             privacy_helper:gets_error(User2, <<"cancel">>, <<"service-unavailable">>),
-            privacy_helper:assert_privacy_check_packet_event(User2, #{dir => out}),
-            privacy_helper:assert_privacy_check_packet_event(User1, #{dir => in, blocked_count => 1})
+            privacy_helper:assert_privacy_check_packet_event(User2, #{dir => out}, TS),
+            privacy_helper:assert_privacy_check_packet_event(User1, #{dir => in, blocked_count => 1}, TS)
         end).
 
 messages_from_unblocked_user_arrive_again(Config) ->
@@ -437,10 +438,11 @@ notify_blockee(Config) ->
 
 %%
 get_blocklist(User) ->
+    TS = instrument_helper:timestamp(),
     IQGet = get_blocklist_stanza(),
     escalus_client:send(User, IQGet),
     Result = escalus_client:wait_for_stanza(User),
-    privacy_helper:assert_privacy_get_event(User),
+    privacy_helper:assert_privacy_get_event(User, TS),
     Result.
 
 %%
@@ -589,14 +591,15 @@ get_blocklist_items(Items) ->
               end, Items).
 
 user_blocks(Blocker, Blockees) when is_list(Blockees) ->
+    TS = instrument_helper:timestamp(),
     BlockeeJIDs = [ escalus_utils:jid_to_lower(escalus_client:short_jid(B)) || B <- Blockees ],
     AddStanza = block_users_stanza(BlockeeJIDs),
     escalus_client:send(Blocker, AddStanza),
     Res = escalus:wait_for_stanzas(Blocker, 2),
     CheckPush = fun(E) -> is_xep191_push(<<"block">>, BlockeeJIDs, E) end,
     Preds = [is_iq_result, CheckPush],
     escalus:assert_many(Preds, Res),
-    privacy_helper:assert_privacy_set_event(Blocker, #{}).
+    privacy_helper:assert_privacy_set_event(Blocker, #{}, TS).
 
 blocklist_is_empty(BlockList) ->
     escalus:assert(is_iq_result, BlockList),
@@ -607,19 +610,21 @@ blocklist_contains_jid(BlockList, Client) ->
     escalus:assert(fun blocklist_result_has/2, [JID], BlockList).
 
 user_unblocks(Unblocker, Unblockees) when is_list(Unblockees) ->
+    TS = instrument_helper:timestamp(),
     UnblockeeJIDs = [ escalus_utils:jid_to_lower(escalus_client:short_jid(B)) || B <- Unblockees ],
     AddStanza = unblock_users_stanza(UnblockeeJIDs),
     escalus_client:send(Unblocker, AddStanza),
     Res = escalus:wait_for_stanzas(Unblocker, 2),
     CheckPush = fun(E) -> is_xep191_push(<<"unblock">>, UnblockeeJIDs, E) end,
     Preds = [is_iq_result, CheckPush],
     escalus:assert_many(Preds, Res),
-    privacy_helper:assert_privacy_set_event(Unblocker, #{});
+    privacy_helper:assert_privacy_set_event(Unblocker, #{}, TS);
 user_unblocks(Unblocker, Unblockee) ->
+    TS = instrument_helper:timestamp(),
     JID = escalus_utils:jid_to_lower(escalus_client:short_jid(Unblockee)),
     escalus_client:send(Unblocker, unblock_user_stanza(JID)),
     user_gets_remove_result(Unblocker, [JID]),
-    privacy_helper:assert_privacy_set_event(Unblocker, #{}).
+    privacy_helper:assert_privacy_set_event(Unblocker, #{}, TS).
 
 blocklist_doesnt_contain_jid(BlockList, Client) ->
     JID = escalus_utils:jid_to_lower(escalus_client:short_jid(Client)),
@@ -642,32 +647,35 @@ message(From, To, MsgTxt) ->
 
 message_is_delivered(From, [To|_] = Tos, MessageText) ->
     BareTo = escalus_utils:jid_to_lower(escalus_client:short_jid(To)),
+    TS = instrument_helper:timestamp(),
     escalus:send(From, escalus_stanza:chat_to(BareTo, MessageText)),
     [ escalus:assert(is_chat_message, [MessageText], escalus:wait_for_stanza(C)) ||
         C <- Tos ],
-    privacy_helper:assert_privacy_check_packet_event(From, #{dir => out}),
-    privacy_helper:assert_privacy_check_packet_event(To, #{dir => in});
+    privacy_helper:assert_privacy_check_packet_event(From, #{dir => out}, TS),
+    privacy_helper:assert_privacy_check_packet_event(To, #{dir => in}, TS);
 message_is_delivered(From, To, MessageText) ->
     BareTo =  escalus_utils:jid_to_lower(escalus_client:short_jid(To)),
+    TS = instrument_helper:timestamp(),
     escalus:send(From, escalus_stanza:chat_to(BareTo, MessageText)),
     escalus:assert(is_chat_message, [MessageText], escalus:wait_for_stanza(To)),
-    privacy_helper:assert_privacy_check_packet_event(From, #{dir => out}),
-    privacy_helper:assert_privacy_check_packet_event(To, #{dir => in}).
+    privacy_helper:assert_privacy_check_packet_event(From, #{dir => out}, TS),
+    privacy_helper:assert_privacy_check_packet_event(To, #{dir => in}, TS).
 
 message_is_blocked_by_recipient(From, To) ->
+    TS = instrument_helper:timestamp(),
     message_is_not_delivered(From, [To], <<"You blocked me!">>),
     privacy_helper:gets_error(From, <<"cancel">>, <<"service-unavailable">>),
-    privacy_helper:assert_privacy_check_packet_event(From, #{dir => out}),
-    privacy_helper:assert_privacy_check_packet_event(To, #{dir => in, blocked_count => 1}).
+    privacy_helper:assert_privacy_check_packet_event(From, #{dir => out}, TS),
+    privacy_helper:assert_privacy_check_packet_event(To, #{dir => in, blocked_count => 1}, TS).
 
 message_is_blocked_by_sender(From, To) ->
+    TS = instrument_helper:timestamp(),
     message_is_not_delivered(From, [To], <<"I blocked you!">>),
     client_gets_blocking_error(From),
-    privacy_helper:assert_privacy_check_packet_event(From, #{dir => out, blocked_count => 1}).
+    privacy_helper:assert_privacy_check_packet_event(From, #{dir => out, blocked_count => 1}, TS).
 
 message_is_not_delivered(From, [To|_] = Tos, MessageText) ->
-    BareTo = escalus_utils:jid_to_lower(escalus_client:short_jid(To)),
-    escalus:send(From, escalus_stanza:chat_to(BareTo, MessageText)),
+    escalus:send(From, escalus_stanza:chat_to(To, MessageText)),
     clients_have_no_messages(Tos).
 
 clients_have_no_messages(Cs) when is_list (Cs) -> [ client_has_no_messages(C) || C <- Cs ].

big_tests/tests/privacy_SUITE.erl

@@ -25,9 +25,11 @@
 -define(SLEEP_TIME, 50).
 
 -import(privacy_helper, [assert_privacy_get_event/1,
+                         assert_privacy_get_event/2,
                          assert_privacy_set_event/2,
-                         assert_privacy_check_packet_event/2,
-                         assert_privacy_push_item_event/2]).
+                         assert_privacy_check_packet_event/3,
+                         assert_privacy_push_item_event/2,
+                         assert_privacy_push_item_event/3]).
 
 %%--------------------------------------------------------------------
 %% Suite configuration
@@ -195,10 +197,11 @@ get_all_lists_with_active(Config) ->
 
         privacy_helper:set_and_activate(Alice, {<<"deny_client">>, Bob}),
 
+        TS = instrument_helper:timestamp(),
         escalus:send(Alice, escalus_stanza:privacy_get_all()),
         escalus:assert(is_privacy_result_with_active, [<<"deny_client">>],
                        escalus:wait_for_stanza(Alice)),
-        assert_privacy_get_event(Alice)
+        assert_privacy_get_event(Alice, TS)
 
         end).
 
@@ -209,10 +212,11 @@ get_all_lists_with_default(Config) ->
         privacy_helper:set_list(Alice, {<<"allow_client">>, Bob}),
         privacy_helper:set_default_list(Alice, <<"allow_client">>),
 
+        TS = instrument_helper:timestamp(),
         escalus:send(Alice, escalus_stanza:privacy_get_all()),
         escalus:assert(is_privacy_result_with_default,
                        escalus:wait_for_stanza(Alice)),
-        assert_privacy_get_event(Alice)
+        assert_privacy_get_event(Alice, TS)
 
         end).
 
@@ -243,13 +247,14 @@ get_existing_list(Config) ->
 
         privacy_helper:set_list(Alice, {<<"deny_client">>, Bob}),
 
+        TS = instrument_helper:timestamp(),
         escalus:send(Alice, escalus_stanza:privacy_get_lists([<<"deny_client">>])),
         Response = escalus:wait_for_stanza(Alice),
 
         <<"deny_client">> = exml_query:path(Response, [{element, <<"query">>},
                                                        {element, <<"list">>},
                                                        {attr, <<"name">>}]),
-        assert_privacy_get_event(Alice)
+        assert_privacy_get_event(Alice, TS)
 
         end).
 
@@ -391,19 +396,24 @@ remove_list(Config) ->
         privacy_helper:send_set_list(Alice, {<<"deny_client">>, Bob}),
 
         %% These are the pushed notification and iq result.
-        escalus_client:wait_for_stanzas(Alice, 2),
+        escalus:assert_many([
+            fun privacy_helper:is_privacy_list_push/1,
+            is_iq_result
+        ], escalus_client:wait_for_stanzas(Alice, 2)),
+        assert_privacy_push_item_event(Alice, 1),
 
         %% Request list deletion by sending an empty list.
         RemoveRequest = escalus_stanza:privacy_set_list(
                           escalus_stanza:privacy_list(<<"someList">>, [])),
         escalus_client:send(Alice, RemoveRequest),
 
         %% These too are the pushed notification and iq result.
+        TS = instrument_helper:timestamp(),
         escalus:assert_many([
             fun privacy_helper:is_privacy_list_push/1,
             is_iq_result
         ], escalus_client:wait_for_stanzas(Alice, 2)),
-        assert_privacy_push_item_event(Alice, 1),
+        assert_privacy_push_item_event(Alice, 1, TS),
 
         escalus_client:send(Alice,
             escalus_stanza:privacy_get_lists([<<"someList">>])),
@@ -432,10 +442,11 @@ block_jid_message(Config) ->
         %% Blocking only applies to incoming messages, so Alice can still send
         %% Bob a message
         %% and Bob gets nothing
+        TS = instrument_helper:timestamp(),
         escalus_client:send(Alice, escalus_stanza:chat_to(Bob, <<"Hi, Bobbb!">>)),
         escalus_assert:is_chat_message(<<"Hi, Bobbb!">>, escalus_client:wait_for_stanza(Bob)),
-        assert_privacy_check_packet_event(Alice, #{dir => out}),
-        assert_privacy_check_packet_event(Bob, #{dir => in})
+        assert_privacy_check_packet_event(Alice, #{dir => out}, TS),
+        assert_privacy_check_packet_event(Bob, #{dir => in}, TS)
 
         end).
 

big_tests/tests/privacy_helper.erl

@@ -5,7 +5,6 @@
 -include_lib("exml/include/exml.hrl").
 -include_lib("escalus/include/escalus.hrl").
 -include_lib("escalus/include/escalus_xmlns.hrl").
--include_lib("common_test/include/ct.hrl").
 
 gets_error(Who, Type) ->
     gets_error(Who, <<"cancel">>, Type).
@@ -29,31 +28,36 @@ send_set_list(Client, List) ->
 
 %% Sets the list on server.
 set_list(Client, {ListName, Target}) ->
+    TS = instrument_helper:timestamp(),
     Stanza = send_set_list(Client, {ListName, Target}),
-    verify_set_list_response(Client),
+    verify_set_list_response(Client, TS),
     verify_list(Client, ListName, Stanza);
 set_list(Client, ListName) ->
+    TS = instrument_helper:timestamp(),
     Stanza = send_set_list(Client, ListName),
-    verify_set_list_response(Client),
+    verify_set_list_response(Client, TS),
     verify_list(Client, ListName, Stanza).
 
 set_list(Client, ListName, NewItems) ->
+    TS = instrument_helper:timestamp(),
     PrivacyList = escalus_stanza:privacy_list(ListName, NewItems),
     Stanza = escalus_stanza:privacy_set_list(PrivacyList),
     escalus:send(Client, Stanza),
-    verify_set_list_response(Client),
+    verify_set_list_response(Client, TS),
     verify_list(Client, ListName, Stanza).
 
-verify_set_list_response(Client) ->
+verify_set_list_response(Client, TS) ->
     Responses = escalus:wait_for_stanzas(Client, 2),
     escalus:assert_many([is_iq_result, is_privacy_set], Responses),
-    assert_privacy_set_event(Client, #{}).
+    assert_privacy_set_event(Client, #{}, TS).
 
 verify_list(Client, ListName, Stanza) ->
+    TS = instrument_helper:timestamp(),
     GetStanza = escalus_stanza:privacy_get_lists([ListName]),
     escalus:send(Client, GetStanza),
     GetResultStanza = escalus:wait_for_stanza(Client),
-    escalus:assert(fun does_result_match_request/3, [Stanza, GetStanza], GetResultStanza).
+    escalus:assert(fun does_result_match_request/3, [Stanza, GetStanza], GetResultStanza),
+    assert_privacy_get_event(Client, TS).
 
 does_result_match_request(SetRequest, GetRequest, Result) ->
     escalus_pred:is_iq_result(GetRequest, Result) andalso
@@ -90,15 +94,17 @@ attr_match(Name, Value, Props) ->
 
 %% Make the list the active one.
 activate_list(Client, ListName) ->
+    TS = instrument_helper:timestamp(),
     escalus:send(Client, escalus_stanza:privacy_activate(ListName)),
     escalus:assert(is_iq_result, escalus:wait_for_stanza(Client)),
-    assert_privacy_set_event(Client, #{active_count => 1}).
+    assert_privacy_set_event(Client, #{active_count => 1}, TS).
 
 %% Make the list the default one.
 set_default_list(Client, ListName) ->
+    TS = instrument_helper:timestamp(),
     escalus:send(Client, escalus_stanza:privacy_set_default(ListName)),
     escalus:assert(is_iq_result, escalus:wait_for_stanza(Client)),
-    assert_privacy_set_event(Client, #{default_count => 1}).
+    assert_privacy_set_event(Client, #{default_count => 1}, TS).
 
 %% Is this iq a notification about a privacy list being changed?
 is_privacy_list_push(Iq) ->
@@ -255,36 +261,58 @@ does_user_process_crash(From, To, Type, Children, Message) ->
                    escalus:wait_for_stanza(To)).
 
 send_and_check_blocked_message(Sender, Recipient) ->
+    TS = instrument_helper:timestamp(),
     escalus_client:send(Sender, escalus_stanza:chat_to(Recipient, <<"Hi, blocker!">>)),
     timer:sleep(100),
     escalus_assert:has_no_stanzas(Recipient),
     privacy_helper:gets_error(Sender, <<"service-unavailable">>),
-    assert_privacy_check_packet_event(Sender, #{dir => out}),
-    assert_privacy_check_packet_event(Recipient, #{dir => in, denied_count => 1}).
+    assert_privacy_check_packet_event(Sender, #{dir => out}, TS),
+    assert_privacy_check_packet_event(Recipient, #{dir => in, denied_count => 1}, TS).
 
-%% Intrumentation events
+%% Instrumentation events
 
 assert_privacy_get_event(Client) ->
-    ClientJid = jid:from_binary(escalus_utils:get_jid(Client)),
-    instrument_helper:assert_one(
-      mod_privacy_get, #{host_type => domain_helper:host_type()},
-      fun(M) -> M =:= #{count => 1, jid => ClientJid} end).
+    assert_event(mod_privacy_get, measurements(Client)).
+
+assert_privacy_get_event(Client, TS) ->
+    assert_event(mod_privacy_get, measurements(Client), TS).
 
 assert_privacy_set_event(Client, ExtraM) ->
-    ClientJid = jid:from_binary(escalus_utils:get_jid(Client)),
-    instrument_helper:assert_one(
-      mod_privacy_set, #{host_type => domain_helper:host_type()},
-      fun(M) -> M =:= maps:merge(#{jid => ClientJid, count => 1}, ExtraM) end).
+    assert_event(mod_privacy_set, measurements(Client, ExtraM)).
+
+assert_privacy_set_event(Client, ExtraM, TS) ->
+    assert_event(mod_privacy_set, measurements(Client, ExtraM), TS).
 
 assert_privacy_check_packet_event(Client, ExtraM) ->
-    ClientJid = jid:from_binary(escalus_utils:get_jid(Client)),
-    instrument_helper:assert_one(
-      mod_privacy_check_packet, #{host_type => domain_helper:host_type()},
-      fun(M) -> M =:= maps:merge(#{jid => ClientJid, count => 1}, ExtraM) end).
+    assert_event(mod_privacy_check_packet, measurements(Client, ExtraM)).
+
+assert_privacy_check_packet_event(Client, ExtraM, TS) ->
+    assert_event(mod_privacy_check_packet, measurements(Client, ExtraM), TS).
 
 assert_privacy_push_item_event(Client, ExpCount) ->
+    assert_event(mod_privacy_push_item, push_item_measurements(Client, ExpCount)).
+
+assert_privacy_push_item_event(Client, ExpCount, TS) ->
+    assert_event(mod_privacy_push_item, push_item_measurements(Client, ExpCount), TS).
+
+measurements(Client, ExtraM) ->
+    maps:merge(measurements(Client), ExtraM).
+
+measurements(Client) ->
+    ClientJid = jid:from_binary(escalus_utils:get_jid(Client)),
+    #{jid => ClientJid, count => 1}.
+
+push_item_measurements(Client, ExpCount) ->
     User = escalus_utils:get_username(Client),
     Server = escalus_utils:get_server(Client),
-    instrument_helper:assert_one(
-      mod_privacy_push_item, #{host_type => domain_helper:host_type()},
-      fun(M) -> M =:= #{user => User, server => Server, count => ExpCount} end).
+    #{user => User, server => Server, count => ExpCount}.
+
+assert_event(Name, Measurements) ->
+    instrument_helper:assert_one(Name, labels(), fun(M) -> M =:= Measurements end).
+
+assert_event(Name, Measurements, TS) ->
+    instrument_helper:assert(Name, labels(), fun(M) -> M =:= Measurements end,
+                             #{expected_count => 1, timestamp => TS}).
+
+labels() ->
+    #{host_type => domain_helper:host_type()}.

big_tests/tests/roster_helper.erl

@@ -17,7 +17,7 @@ assert_roster_event(Client, Event) ->
     ClientJid = jid:from_binary(escalus_utils:get_jid(Client)),
     instrument_helper:assert_one(
       Event, #{host_type => host_type()},
-      fun(#{count := 1, jid := Jid}) -> jid:are_bare_equal(ClientJid, Jid) end).
+      fun(#{count := 1, jid := Jid}) -> ClientJid =:= Jid end).
 
 assert_subscription_event(FromClient, ToClient, CheckF) ->
     FromClientJid = jid:from_binary(escalus_utils:get_short_jid(FromClient)),