1: -module(inbox_SUITE). 2: -compile([export_all, nowarn_export_all]). 3: 4: -include_lib("common_test/include/ct.hrl"). 5: -include_lib("eunit/include/eunit.hrl"). 6: -include_lib("escalus/include/escalus_xmlns.hrl"). 7: -include_lib("exml/include/exml.hrl"). 8: -include_lib("jid/include/jid.hrl"). 9: -include_lib("inbox.hrl"). 10: 11: %% tests 12: -import(muc_light_helper, [room_bin_jid/1]). 13: -import(inbox_helper, [ 14: inbox_modules/0, 15: muclight_modules/0, 16: inbox_opts/0, 17: muc_domain/0, 18: parse_form_iq/1, 19: check_inbox/2, check_inbox/3, 20: check_inbox/4, 21: clear_inbox_all/0, 22: given_conversations_between/2, 23: assert_invalid_inbox_form_value_error/3, 24: assert_invalid_reset_inbox/4, 25: extract_user_specs/1 26: ]). 27: 28: -define(ROOM3, <<"testroom3">>). 29: -define(ROOM4, <<"testroom4">>). 30: 31: %%-------------------------------------------------------------------- 32: %% Suite configuration 33: %%-------------------------------------------------------------------- 34: 35: all() -> 36: inbox_helper:skip_or_run_inbox_tests(tests()). 37: 38: tests() -> 39: [ 40: {group, generic}, 41: {group, one_to_one}, 42: {group, muclight}, 43: {group, muclight_config}, 44: {group, muc}, 45: {group, timestamps} 46: ]. 47: 48: groups() -> 49: Gs = [ 50: {generic, [], 51: [ 52: disco_service, 53: returns_valid_form, 54: returns_error_when_first_bad_form_field_encountered, 55: returns_error_when_bad_form_field_start_sent, 56: returns_error_when_bad_form_field_end_sent, 57: returns_error_when_bad_form_field_order_sent, 58: returns_error_when_bad_form_field_hidden_read_sent, 59: returns_error_when_bad_reset_field_jid, 60: returns_error_when_no_reset_field_jid, 61: returns_error_when_unknown_field_sent 62: ]}, 63: {one_to_one, [], 64: [ 65: user_has_empty_inbox, 66: msg_sent_stored_in_inbox, 67: msg_sent_stored_in_inbox_iq_id_as_queryid_fallback, 68: msg_sent_stored_in_inbox_queryid, 69: msg_with_no_store_is_not_stored_in_inbox, 70: msg_with_store_hint_is_always_stored, 71: carbons_are_not_stored, 72: user_has_two_conversations, 73: msg_sent_to_offline_user, 74: msg_sent_to_not_existing_user, 75: user_has_two_unread_messages, 76: other_resources_do_not_interfere, 77: reset_unread_counter_with_reset_chat_marker, 78: reset_unread_counter_with_reset_stanza, 79: try_to_reset_unread_counter_with_bad_marker, 80: non_reset_marker_should_not_affect_inbox, 81: user_has_only_unread_messages_or_only_read, 82: reset_unread_counter_and_show_only_unread, 83: check_total_unread_count_and_active_conv_count, 84: check_total_unread_count_when_there_are_no_active_conversations, 85: total_unread_count_and_active_convs_are_zero_at_no_activity 86: ]}, 87: {muclight, [], 88: [ 89: simple_groupchat_stored_in_all_inbox, 90: advanced_groupchat_stored_in_all_inbox, 91: groupchat_markers_one_reset, 92: non_reset_marker_should_not_affect_muclight_inbox, 93: groupchat_reset_stanza_resets_inbox, 94: create_groupchat, 95: leave_and_remove_conversation, 96: groupchat_markers_one_reset_room_created, 97: groupchat_markers_all_reset_room_created, 98: inbox_does_not_trigger_does_user_exist 99: ]}, 100: {muclight_config, [sequence], 101: [ 102: create_groupchat_no_affiliation_stored, 103: leave_and_store_conversation, 104: no_aff_stored_and_remove_on_kicked, 105: no_stored_and_remain_after_kicked, 106: system_message_is_correctly_avoided 107: ]}, 108: {muc, [], 109: [ 110: simple_groupchat_stored_in_all_inbox_muc, 111: simple_groupchat_stored_in_offline_users_inbox_muc, 112: unread_count_is_the_same_after_going_online_again, 113: unread_count_is_reset_after_sending_chatmarker, 114: non_reset_marker_should_not_affect_muc_inbox, 115: unread_count_is_reset_after_sending_reset_stanza, 116: private_messages_are_handled_as_one2one 117: ]}, 118: {timestamps, [], 119: [ 120: timestamp_is_updated_on_new_message, 121: order_by_timestamp_ascending, 122: get_by_timestamp_range, 123: get_with_start_timestamp, 124: get_with_end_timestamp 125: ]} 126: ], 127: inbox_helper:maybe_run_in_parallel(Gs). 128: 129: suite() -> 130: escalus:suite(). 131: 132: %%-------------------------------------------------------------------- 133: %% Init & teardown 134: %%-------------------------------------------------------------------- 135: 136: init_per_suite(Config0) -> 137: Config1 = dynamic_modules:save_modules(domain_helper:host_type(), Config0), 138: ok = dynamic_modules:ensure_modules( 139: domain_helper:host_type(), inbox_modules()), 140: ok = dynamic_modules:ensure_modules( 141: ct:get_config({hosts, mim, secondary_host_type}), 142: [{mod_inbox, 143: [{aff_changes, false}, 144: {remove_on_kicked, true}, 145: {groupchat, [muclight]}, 146: {markers, [displayed]}]}]), 147: InboxOptions = inbox_opts(), 148: mongoose_helper:inject_module(?MODULE), 149: escalus:init_per_suite([{inbox_opts, InboxOptions} | Config1]). 150: 151: end_per_suite(Config) -> 152: escalus_fresh:clean(), 153: dynamic_modules:stop(ct:get_config({hosts, mim, secondary_host_type}), mod_inbox), 154: dynamic_modules:restore_modules(Config), 155: escalus:end_per_suite(Config). 156: 157: init_per_group(one_to_one, Config) -> 158: dynamic_modules:ensure_modules(domain_helper:host_type(), [{mod_offline, []}]), 159: inbox_helper:reload_inbox_option(Config, groupchat, []); 160: init_per_group(muclight, Config) -> 161: ok = dynamic_modules:ensure_modules(domain_helper:host_type(mim), muclight_modules()), 162: inbox_helper:reload_inbox_option(Config, groupchat, [muclight]), 163: [{group, muclight} | Config]; 164: init_per_group(muclight_config, Config) -> 165: ok = dynamic_modules:ensure_modules(domain_helper:host_type(mim), muclight_modules()), 166: Config1 = inbox_helper:reload_inbox_option(Config, groupchat, [muclight]), 167: escalus:create_users(Config1, escalus:get_users([alice, alice_bis, bob, kate, mike])); 168: init_per_group(muc, Config) -> 169: muc_helper:load_muc(), 170: inbox_helper:reload_inbox_option(Config, groupchat, [muc]); 171: init_per_group(_GroupName, Config) -> 172: Config. 173: 174: end_per_group(muc, _Config) -> 175: HostType = domain_helper:host_type(mim), 176: dynamic_modules:stop(HostType, mod_muc); 177: end_per_group(muclight, Config) -> 178: HostType = domain_helper:host_type(mim), 179: muc_light_helper:clear_db(HostType), 180: dynamic_modules:stop(HostType, mod_muc_light), 181: Config; 182: end_per_group(muclight_config, Config) -> 183: HostType = domain_helper:host_type(mim), 184: muc_light_helper:clear_db(HostType), 185: dynamic_modules:stop(HostType, mod_muc_light), 186: escalus:delete_users(Config, escalus:get_users([alice, alice_bis, bob, kate, mike])); 187: end_per_group(_GroupName, Config) -> 188: Config. 189: 190: 191: init_per_testcase(TS, Config) 192: when TS =:= create_groupchat_no_affiliation_stored; 193: TS =:= system_message_is_correctly_avoided -> 194: clear_inbox_all(), 195: inbox_helper:reload_inbox_option(Config, aff_changes, false), 196: escalus:init_per_testcase(TS, Config); 197: init_per_testcase(leave_and_store_conversation, Config) -> 198: clear_inbox_all(), 199: inbox_helper:reload_inbox_option(Config, remove_on_kicked, false), 200: escalus:init_per_testcase(leave_and_store_conversation, Config); 201: init_per_testcase(no_aff_stored_and_remove_on_kicked, Config) -> 202: clear_inbox_all(), 203: muc_light_helper:create_room(?ROOM3, muc_light_helper:muc_host(), alice, [bob, kate], 204: Config, muc_light_helper:ver(1)), 205: inbox_helper:reload_inbox_option(Config, [{remove_on_kicked, true}, {aff_changes, false}]), 206: escalus:init_per_testcase(no_aff_stored_and_remove_on_kicked, Config); 207: init_per_testcase(no_stored_and_remain_after_kicked, Config) -> 208: clear_inbox_all(), 209: muc_light_helper:create_room(?ROOM4, muc_light_helper:muc_host(), alice, [bob, kate], 210: Config, muc_light_helper:ver(1)), 211: inbox_helper:reload_inbox_option(Config, [{remove_on_kicked, false}, {aff_changes, true}]), 212: escalus:init_per_testcase(no_stored_and_remain_after_kicked, Config); 213: init_per_testcase(CaseName, Config) -> 214: escalus:init_per_testcase(CaseName, Config). 215: 216: end_per_testcase(TS, Config) 217: when TS =:= create_groupchat_no_affiliation_stored; 218: TS =:= system_message_is_correctly_avoided -> 219: clear_inbox_all(), 220: inbox_helper:restore_inbox_option(Config), 221: escalus:end_per_testcase(TS, Config); 222: end_per_testcase(leave_and_store_conversation, Config) -> 223: clear_inbox_all(), 224: inbox_helper:restore_inbox_option(Config), 225: escalus:end_per_testcase(leave_and_store_conversation, Config); 226: end_per_testcase(no_aff_stored_and_remove_on_kicked, Config) -> 227: clear_inbox_all(), 228: inbox_helper:restore_inbox_option(Config), 229: escalus:end_per_testcase(no_aff_stored_and_remove_on_kicked, Config); 230: end_per_testcase(no_stored_and_remain_after_kicked, Config) -> 231: clear_inbox_all(), 232: inbox_helper:restore_inbox_option(Config), 233: escalus:end_per_testcase(no_stored_and_remain_after_kicked, Config); 234: end_per_testcase(msg_sent_to_not_existing_user, Config) -> 235: HostType = domain_helper:host_type(mim), 236: escalus_ejabberd:rpc(mod_inbox_utils, clear_inbox, [HostType, <<"not_existing_user">>,<<"localhost">>]), 237: escalus:end_per_testcase(msg_sent_to_not_existing_user, Config); 238: end_per_testcase(CaseName, Config) -> 239: escalus:end_per_testcase(CaseName, Config). 240: 241: 242: %%-------------------------------------------------------------------- 243: %% Generic Inbox tests 244: %%-------------------------------------------------------------------- 245: 246: disco_service(Config) -> 247: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 248: Server = escalus_client:server(Alice), 249: escalus:send( 250: Alice, escalus_stanza:to(escalus_stanza:iq_get(?NS_DISCO_INFO, []), Server)), 251: Stanza = escalus:wait_for_stanza(Alice), 252: Features = exml_query:paths(Stanza, [{element, <<"query">>}, 253: {element, <<"feature">>}, 254: {attr, <<"var">>}]), 255: ?assertEqual(true, lists:member(inbox_helper:inbox_ns(), Features)) 256: end). 257: 258: returns_valid_form(Config) -> 259: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 260: escalus:send(Alice, inbox_helper:get_inbox_form_stanza()), 261: ResIQ = escalus:wait_for_stanza(Alice), 262: InboxNS = inbox_helper:inbox_ns(), 263: #{ field_count := 6 } = Form = parse_form_iq(ResIQ), 264: #{ <<"FORM_TYPE">> := #{ type := <<"hidden">>, 265: value := InboxNS } } = Form, 266: #{ <<"start">> := #{ type := <<"text-single">> } } = Form, 267: #{ <<"end">> := #{ type := <<"text-single">> } } = Form, 268: #{ <<"order">> := #{ type := <<"list-single">>, 269: value := <<"desc">>, 270: options := OrderOptions } } = Form, 271: [<<"asc">>, <<"desc">>] = lists:sort(OrderOptions), 272: #{ <<"hidden_read">> := #{ type := <<"text-single">> } } = Form 273: end). 274: 275: returns_error_when_bad_form_field_order_sent(Config) -> 276: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 277: assert_invalid_inbox_form_value_error(Alice, <<"order">>, <<"invalid">>) 278: end). 279: 280: returns_error_when_bad_form_field_start_sent(Config) -> 281: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 282: assert_invalid_inbox_form_value_error(Alice, <<"start">>, <<"invalid">>) 283: end). 284: 285: returns_error_when_bad_form_field_end_sent(Config) -> 286: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 287: assert_invalid_inbox_form_value_error(Alice, <<"end">>, <<"invalid">>) 288: end). 289: 290: returns_error_when_bad_form_field_hidden_read_sent(Config) -> 291: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 292: assert_invalid_inbox_form_value_error(Alice, <<"hidden_read">>, <<"invalid">>) 293: end). 294: 295: returns_error_when_bad_reset_field_jid(Config) -> 296: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 297: assert_invalid_reset_inbox( 298: Alice, <<"$@/">>, <<"jid">>, <<"invalid-jid">>) 299: end). 300: 301: returns_error_when_no_reset_field_jid(Config) -> 302: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 303: assert_invalid_reset_inbox( 304: Alice, undefined, <<"jid">>, <<"jid-required">>) 305: end). 306: 307: 308: returns_error_when_first_bad_form_field_encountered(Config) -> 309: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 310: Stanza = inbox_helper:make_inbox_stanza( #{ <<"start">> => <<"invalid">>, 311: <<"end">> => <<"invalid">>}, false), 312: escalus:send(Alice, Stanza), 313: [ResIQ] = escalus:wait_for_stanzas(Alice, 1), 314: escalus_pred:is_iq_error(ResIQ), 315: ErrorMsg = inbox_helper:get_error_message(ResIQ), 316: inbox_helper:assert_message_content(ErrorMsg, <<"field=end">>, <<"value=invalid">>) 317: end). 318: 319: returns_error_when_unknown_field_sent(Config) -> 320: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 321: Stanza = inbox_helper:make_inbox_stanza( #{ <<"unknown_field">> => <<"unknown_field_value">> }, false), 322: escalus:send(Alice, Stanza), 323: [ResIQ] = escalus:wait_for_stanzas(Alice, 1), 324: escalus_pred:is_iq_error(ResIQ), 325: ErrorMsg = inbox_helper:get_error_message(ResIQ), 326: inbox_helper:assert_message_content(ErrorMsg, <<"field=unknown_field">>, <<"value=unknown_field_value">>) 327: end). 328: 329: 330: %%-------------------------------------------------------------------- 331: %% Inbox tests one-to-one 332: %%-------------------------------------------------------------------- 333: 334: user_has_empty_inbox(Config) -> 335: escalus:fresh_story(Config, [{kate, 1}], fun(Kate) -> 336: Stanza = inbox_helper:make_inbox_stanza(), 337: %% Kate logs in for first time and ask for inbox 338: escalus:send(Kate, Stanza), 339: [ResIQ] = escalus:wait_for_stanzas(Kate, 1), 340: true = escalus_pred:is_iq_result(ResIQ), 341: %% Inbox is empty 342: TotalCount = inbox_helper:get_result_el(ResIQ, <<"count">>), 343: 0 = TotalCount 344: end). 345: 346: msg_sent_stored_in_inbox(Config) -> 347: test_msg_stored_in_inbox(Config, undefined). 348: 349: msg_sent_stored_in_inbox_iq_id_as_queryid_fallback(Config) -> 350: test_msg_stored_in_inbox(Config, iq_id). 351: 352: msg_sent_stored_in_inbox_queryid(Config) -> 353: test_msg_stored_in_inbox(Config, queryid). 354: 355: test_msg_stored_in_inbox(Config, QueryId) -> 356: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}], fun(Alice, Bob) -> 357: #{ Alice := AliceConvs, Bob := BobConvs } = given_conversations_between(Alice, [Bob]), 358: %% Both check inbox 359: check_inbox(Alice, AliceConvs, inbox_helper:maybe_make_queryid(QueryId)), 360: check_inbox(Bob, BobConvs, inbox_helper:maybe_make_queryid(QueryId)) 361: end). 362: 363: msg_with_no_store_is_not_stored_in_inbox(Config) -> 364: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}], fun(Alice, Bob) -> 365: %% Alice sends a message to Bob with a no-store hint 366: Body = <<"test">>, 367: Msg1 = escalus_stanza:chat_to(Bob, Body), 368: Msg2 = escalus_stanza:set_id(Msg1, escalus_stanza:id()), 369: Msg3 = mam_helper:add_nostore_hint(Msg2), 370: escalus:send(Alice, Msg3), 371: MsgSent = escalus:wait_for_stanza(Bob), 372: escalus:assert(is_chat_message, MsgSent), 373: %% Bob has no unread messages in conversation with Alice 374: check_inbox(Bob, []), 375: %% Alice has no conv in her inbox either 376: check_inbox(Alice, []) 377: end). 378: 379: msg_with_store_hint_is_always_stored(Config) -> 380: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}], fun(Alice, Bob) -> 381: %% Alice sends a message to Bob with a store hint, that would otherwise be ignored 382: Msg1 = escalus_stanza:to(#xmlel{name = <<"message">>}, Bob), 383: Msg2 = escalus_stanza:set_id(Msg1, escalus_stanza:id()), 384: Msg3 = mam_helper:add_store_hint(Msg2), 385: escalus:send(Alice, Msg3), 386: escalus:wait_for_stanza(Bob), 387: %% Alice and Bob has a body-less message in their inbox 388: check_inbox(Bob, [#conv{unread = 1, from = Alice, to = Bob, content = <<>>}]), 389: check_inbox(Alice, [#conv{unread = 0, from = Alice, to = Bob, content = <<>>}]) 390: end). 391: 392: carbons_are_not_stored(Config) -> 393: escalus:fresh_story(Config, [{alice, 2}, {bob, 2}], fun(Alice1, Alice2, Bob1, Bob2) -> 394: mongoose_helper:enable_carbons([Alice1, Alice2, Bob1, Bob2]), 395: #{ Alice1 := AliceConvs, Bob1 := BobConvs } = given_conversations_between(Alice1, [Bob1]), 396: %% Both check inbox and carbons aren't there 397: check_inbox(Alice1, AliceConvs), 398: check_inbox(Bob1, BobConvs) 399: end). 400: 401: user_has_two_conversations(Config) -> 402: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 403: #{ Alice := AliceConvs, Bob := BobConvs, Kate := KateConvs } = 404: given_conversations_between(Alice, [Bob, Kate]), 405: 406: %% Alice has two conversations in her inbox (no unread messages) 407: check_inbox(Alice, AliceConvs), 408: 409: %% Kate has one conversation with one unread 410: check_inbox(Kate, KateConvs), 411: 412: %% Bob has one conversation with one unread 413: check_inbox(Bob, BobConvs) 414: end). 415: 416: user_has_only_unread_messages_or_only_read(Config) -> 417: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 418: given_conversations_between(Alice, [Bob, Kate]), 419: % Alice has no unread messages, but requests all conversations 420: inbox_helper:get_inbox(Alice, #{ hidden_read => false }, #{count => 2}), 421: 422: % Requests only conversations with unread messages 423: inbox_helper:get_inbox(Alice, #{ hidden_read => true }, #{count => 0}), 424: % Bob has only one, unread message 425: inbox_helper:get_inbox(Bob, #{ hidden_read => true }, #{count => 1}) 426: end). 427: 428: msg_sent_to_offline_user(Config) -> 429: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}], fun(Alice, Bob) -> 430: %% Bob goes offline 431: mongoose_helper:logout_user(Config, Bob), 432: 433: %% Alice sends a message to Bob 434: Msg1 = escalus_stanza:chat_to(Bob, <<"test">>), 435: escalus:send(Alice, Msg1), 436: 437: %% Bob goes online again 438: {_, BobSpecs} = extract_user_specs(Bob), 439: {ok, NewBob} = escalus_client:start(Config, BobSpecs, <<"new-session">>), 440: escalus:send(NewBob, escalus_stanza:presence(<<"available">>)), 441: Stanzas = escalus:wait_for_stanzas(NewBob, 2), 442: 443: escalus_new_assert:mix_match 444: ([is_presence, fun(Stanza) -> escalus_pred:is_chat_message(<<"test">>, Stanza) end], 445: Stanzas), 446: 447: %% Alice has conversation 448: check_inbox(Alice, [#conv{unread = 0, from = Alice, to = Bob, content = <<"test">>}]), 449: 450: %% Both check inbox and has a conversation 451: check_inbox(NewBob, [#conv{unread = 1, from = Alice, to = Bob, content = <<"test">>}]) 452: end). 453: 454: msg_sent_to_not_existing_user(Config) -> 455: escalus:fresh_story(Config, [{alice, 1}], fun(Alice) -> 456: %% Alice sends message to user that doesnt exist 457: Msg1 = escalus_stanza:chat_to(<<"not_existing_user@localhost">>, <<"test2">>), 458: escalus:send(Alice, Msg1), 459: 460: %% Alice receives error 461: ServiceUnavailable = escalus:wait_for_stanza(Alice), 462: escalus_pred:is_error(<<"cancel">>,<<"service-unavailable">>, ServiceUnavailable), 463: 464: %% Alice has this conversation in inbox. 465: check_inbox(Alice,[#conv{unread = 0, 466: from = Alice, 467: to = <<"not_existing_user@localhost">>, 468: content = <<"test2">>}]) 469: end). 470: 471: user_has_two_unread_messages(Config) -> 472: escalus:fresh_story(Config, [{kate, 1}, {mike, 1}], fun(Kate, Mike) -> 473: inbox_helper:send_msg(Kate, Mike, "Hello"), 474: inbox_helper:send_msg(Kate, Mike, "How are you"), 475: %% Mike has two unread messages in conversation with Kate 476: check_inbox(Mike, [#conv{unread = 2, from = Kate, to = Mike, content = <<"How are you">>}]), 477: %% Kate has one conv in her inbox (no unread messages) 478: check_inbox(Kate, [#conv{unread = 0, from = Kate, to = Mike, content = <<"How are you">>}]) 479: end). 480: 481: other_resources_do_not_interfere(Config) -> 482: %% regression test 483: escalus:fresh_story(Config, [{kate, 2}, {mike, 1}], fun(Kate, Kate2, Mike) -> 484: Prio = #xmlel{name = <<"priority">>, children = [#xmlcdata{content = <<"100">>}]}, 485: escalus_client:send(Kate2, escalus_stanza:presence(<<"available">>, [Prio])), 486: escalus_client:wait_for_stanza(Kate), 487: inbox_helper:send_msg(Kate, Mike, "Hello"), 488: inbox_helper:send_msg(Kate, Mike, "How are you"), 489: %% Mike has two unread messages in conversation with Kate 490: check_inbox(Mike, [#conv{unread = 2, from = Kate, to = Mike, content = <<"How are you">>}]), 491: %% Kate has one conv in her inbox (no unread messages) 492: check_inbox(Kate, [#conv{unread = 0, from = Kate, to = Mike, content = <<"How are you">>}]) 493: end). 494: 495: reset_unread_counter_with_reset_chat_marker(Config) -> 496: escalus:fresh_story(Config, [{kate, 1}, {mike, 1}], fun(Kate, Mike) -> 497: Msg = inbox_helper:send_msg(Kate, Mike, <<"Hi mike">>), 498: MsgId = exml_query:attr(Msg, <<"id">>), 499: 500: %% Mike has one unread message 501: check_inbox(Mike, [#conv{unread = 1, from = Kate, to = Mike, content = <<"Hi mike">>}]), 502: ChatMarker = escalus_stanza:chat_marker(Kate, <<"displayed">>, MsgId), 503: %% Mike sends "displayed" chat marker to Kate 504: escalus:send(Mike, ChatMarker), 505: %% Now Mike asks for inbox second time. He has 0 unread messages now 506: check_inbox(Mike, [#conv{unread = 0, from = Kate, to = Mike, content = <<"Hi mike">>}]) 507: end). 508: 509: reset_unread_counter_with_reset_stanza(Config) -> 510: escalus:fresh_story(Config, [{kate, 1}, {mike, 1}], fun(Kate, Mike) -> 511: _Msg = inbox_helper:send_msg(Kate, Mike, <<"Hi mike">>), 512: 513: %% Mike has one unread message 514: check_inbox(Mike, [#conv{unread = 1, from = Kate, to = Mike, content = <<"Hi mike">>}]), 515: %% Mike sends "reset" stanza 516: inbox_helper:reset_inbox(Mike, Kate), 517: %% Now Mike asks for inbox second time. He has 0 unread messages now 518: check_inbox(Mike, [#conv{unread = 0, from = Kate, to = Mike, content = <<"Hi mike">>}]), 519: %% Kate should not be receiving this stanza 520: inbox_helper:assert_has_no_stanzas(Kate) 521: end). 522: 523: reset_unread_counter_and_show_only_unread(Config) -> 524: escalus:fresh_story(Config, [{kate, 1}, {mike, 1}, {alice, 1}], fun(Kate, Mike, Alice) -> 525: Msg = inbox_helper:send_msg(Kate, Mike), 526: MsgId = exml_query:attr(Msg, <<"id">>), 527: inbox_helper:get_inbox(Mike, #{ hidden_read => true }, #{count => 1}), 528: 529: ChatMarker = escalus_stanza:chat_marker(Kate, <<"displayed">>, MsgId), 530: escalus:send(Mike, ChatMarker), 531: 532: inbox_helper:get_inbox(Mike, #{ hidden_read => true }, #{count => 0}), 533: 534: inbox_helper:send_msg(Alice, Mike), 535: % Mike has two conversations, one with unread messages 536: inbox_helper:get_inbox(Mike, #{ hidden_read => true }, #{count => 1}), 537: inbox_helper:get_inbox(Mike, #{ hidden_read => false }, #{count => 2}) 538: end). 539: 540: check_total_unread_count_and_active_conv_count(Config) -> 541: escalus:fresh_story(Config, [{kate, 1}, {mike, 1}, {alice, 1}], fun(Kate, Mike, Alice) -> 542: inbox_helper:send_and_mark_msg(Kate, Mike), 543: inbox_helper:send_msg(Alice, Mike), 544: inbox_helper:send_msg(Alice, Mike), 545: inbox_helper:send_msg(Kate, Mike), 546: inbox_helper:get_inbox(Mike, #{count => 2, unread_messages => 3, active_conversations => 2}) 547: end). 548: 549: check_total_unread_count_when_there_are_no_active_conversations(Config) -> 550: escalus:fresh_story(Config, [{kate, 1}, {mike, 1}], fun(Kate, Mike) -> 551: inbox_helper:send_and_mark_msg(Kate, Mike), 552: 553: inbox_helper:get_inbox(Mike, #{count => 1, unread_messages => 0, active_conversations => 0}) 554: end). 555: 556: total_unread_count_and_active_convs_are_zero_at_no_activity(Config) -> 557: escalus:fresh_story(Config, [{kate, 1}], fun(Kate) -> 558: inbox_helper:get_inbox(Kate, #{count => 0, unread_messages => 0, active_conversations => 0}) 559: end). 560: 561: 562: 563: try_to_reset_unread_counter_with_bad_marker(Config) -> 564: escalus:fresh_story(Config, [{kate, 1}, {mike, 1}], fun(Kate, Mike) -> 565: Msg1 = escalus_stanza:set_id(escalus_stanza:chat_to(Mike, <<"okey dockey">>), <<"111">>), 566: %% Kate sends message to Mike 567: escalus:send(Kate, Msg1), 568: M1 = escalus:wait_for_stanza(Mike), 569: escalus:assert(is_chat_message, M1), 570: %% Mike has one unread message 571: check_inbox(Mike, [#conv{unread = 1, from = Kate, to = Mike, content = <<"okey dockey">>}]), 572: MsgId = <<"badId">>, 573: ChatMarker = escalus_stanza:chat_marker(Kate, <<"displayed">>, MsgId), 574: %% Mike sends "displayed" chat marker but 'id' field is wrong 575: escalus:send(Mike, ChatMarker), 576: %% Now Mike asks for inbox second time. Unread count should be still the same 577: check_inbox(Mike, [#conv{unread = 1, from = Kate, to = Mike, content = <<"okey dockey">>}]) 578: end). 579: 580: non_reset_marker_should_not_affect_inbox(Config) -> 581: escalus:fresh_story(Config, [{kate, 1}, {mike, 1}], fun(Kate, Mike) -> 582: MsgId = <<"kate_to_mike">>, 583: MsgBody = <<"okey dockey">>, 584: Msg = escalus_stanza:set_id(escalus_stanza:chat_to(Mike, MsgBody), MsgId), 585: %% Kate sends message to Mike 586: escalus:send(Kate, Msg), 587: M1 = escalus:wait_for_stanza(Mike), 588: escalus:assert(is_chat_message, M1), 589: %% Mike has one unread message 590: check_inbox(Mike, [#conv{unread = 1, from = Kate, to = Mike, content = MsgBody}]), 591: ChatMarker = escalus_stanza:chat_marker(Kate, <<"received">>, MsgId), 592: %% Mike sends "received" chat marker, which is not a reset_marker 593: escalus:send(Mike, ChatMarker), 594: CM = escalus:wait_for_stanza(Kate), 595: escalus:assert(is_message, CM), 596: %% Now Mike asks for inbox second time. Unread count should be still the same 597: check_inbox(Mike, [#conv{unread = 1, from = Kate, to = Mike, content = MsgBody}]), 598: check_inbox(Kate, [], #{hidden_read => true}, #{}) 599: end). 600: 601: %%-------------------------------------------------------------------- 602: %% Inbox tests muclight 603: %%-------------------------------------------------------------------- 604: 605: simple_groupchat_stored_in_all_inbox(Config) -> 606: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 607: Msg = <<"Hi Room!">>, 608: Id = <<"MyID">>, 609: Users = [Alice, Bob, Kate], 610: Room = inbox_helper:create_room(Alice, [Bob, Kate]), 611: AliceJid = inbox_helper:to_bare_lower(Alice), 612: KateJid = inbox_helper:to_bare_lower(Kate), 613: BobJid = inbox_helper:to_bare_lower(Bob), 614: RoomJid = room_bin_jid(Room), 615: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 616: Stanza = escalus_stanza:set_id( 617: escalus_stanza:groupchat_to(RoomJid, Msg), Id), 618: %% Alice sends message to a room 619: escalus:send(Alice, Stanza), 620: inbox_helper:wait_for_groupchat_msg(Users), 621: %% Alice has 0 unread messages 622: check_inbox(Alice, [#conv{unread = 0, from = AliceRoomJid, to = AliceJid, content = Msg}]), 623: %% Bob and Kate have one conv with 1 unread message 624: check_inbox(Bob, [#conv{unread = 1, from = AliceRoomJid, to = BobJid, content = Msg}]), 625: check_inbox(Kate, [#conv{unread = 1, from = AliceRoomJid, to = KateJid, content = Msg}]) 626: end). 627: 628: advanced_groupchat_stored_in_all_inbox(Config) -> 629: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 630: Msg1 = <<"Hi Room!">>, 631: Msg2 = <<"How are you?">>, 632: Id1 = <<"id-1">>, 633: Id2 = <<"id-2">>, 634: Users = [Alice, Bob, Kate], 635: Room = inbox_helper:create_room(Alice, [Bob, Kate]), 636: BobJid = inbox_helper:to_bare_lower(Bob), 637: AliceJid = inbox_helper:to_bare_lower(Alice), 638: KateJid = inbox_helper:to_bare_lower(Kate), 639: RoomJid = room_bin_jid(Room), 640: BobRoomJid = <<RoomJid/binary, "/", BobJid/binary>>, 641: Stanza1 = escalus_stanza:set_id( 642: escalus_stanza:groupchat_to(RoomJid, Msg1), Id1), 643: %% Alice sends msg to room 644: escalus:send(Alice, Stanza1), 645: inbox_helper:wait_for_groupchat_msg(Users), 646: %% Bob sends second message 647: Stanza2 = escalus_stanza:set_id( 648: escalus_stanza:groupchat_to(RoomJid, Msg2), Id2), 649: escalus:send(Bob, Stanza2), 650: inbox_helper:wait_for_groupchat_msg(Users), 651: %% Alice have one unread message (from Bob) 652: check_inbox(Alice, [#conv{unread = 1, from = BobRoomJid, to = AliceJid, content = Msg2}]), 653: %% Bob has 0 unread messages because he sent the last message 654: check_inbox(Bob, [#conv{unread = 0, from = BobRoomJid, to = BobJid, content = Msg2}]), 655: %% Kate has 2 unread messages (from Alice and Bob) 656: check_inbox(Kate, [#conv{unread = 2, from = BobRoomJid, to = KateJid, content = Msg2}]) 657: end). 658: 659: groupchat_markers_one_reset(Config) -> 660: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 661: AliceJid = inbox_helper:to_bare_lower(Alice), 662: BobJid = inbox_helper:to_bare_lower(Bob), 663: KateJid = inbox_helper:to_bare_lower(Kate), 664: Room = inbox_helper:create_room(Alice, [Bob, Kate]), 665: RoomJid = room_bin_jid(Room), 666: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 667: Id = <<"markerId">>, 668: Users = [Alice, Bob, Kate], 669: Stanza1 = escalus_stanza:set_id( 670: escalus_stanza:groupchat_to(RoomJid, <<"marker time!">>), Id), 671: escalus:send(Alice, Stanza1), 672: inbox_helper:wait_for_groupchat_msg(Users), 673: ChatMarkerWOType = escalus_stanza:chat_marker(RoomJid,<<"displayed">>, Id), 674: ChatMarker = escalus_stanza:setattr(ChatMarkerWOType, <<"type">>, <<"groupchat">>), 675: %% User marks last message 676: escalus:send(Bob, ChatMarker), 677: %% participants receive marker 678: muc_helper:foreach_recipient([Alice, Bob, Kate], fun(Marker) -> 679: true = escalus_pred:is_chat_marker(<<"displayed">>, Id, Marker) end), 680: %% Bob has 0 unread messages because he reset his counter 681: check_inbox(Bob, [#conv{unread = 0, from = AliceRoomJid, 682: to = BobJid, content = <<"marker time!">>}]), 683: %% Alice has 0 unread messages because she was the sender 684: check_inbox(Alice, [#conv{unread = 0, from = AliceRoomJid, 685: to = AliceJid, content = <<"marker time!">>}]), 686: %% Kate still has unread message 687: check_inbox(Kate, [#conv{unread = 1, from = AliceRoomJid, 688: to = KateJid, content = <<"marker time!">>}]) 689: end). 690: 691: non_reset_marker_should_not_affect_muclight_inbox(Config) -> 692: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 693: % %% GIVEN 694: AliceJid = inbox_helper:to_bare_lower(Alice), 695: BobJid = inbox_helper:to_bare_lower(Bob), 696: KateJid = inbox_helper:to_bare_lower(Kate), 697: Room = inbox_helper:create_room(Alice, [Bob, Kate]), 698: RoomJid = room_bin_jid(Room), 699: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 700: Msg = <<"marker time!">>, 701: Users = [Alice, Bob, Kate], 702: % %% WHEN DONE 703: Stanza1 = escalus_stanza:set_id( 704: escalus_stanza:groupchat_to(RoomJid, Msg), escalus_stanza:id()), 705: escalus:send(Alice, Stanza1), 706: inbox_helper:wait_for_groupchat_msg(Users), 707: % %% AND MARKED WRONG 708: inbox_helper:mark_last_muclight_message(Bob, [Alice, Bob, Kate], <<"received">>), 709: inbox_helper:mark_last_muclight_message(Kate, [Alice, Bob, Kate], <<"acknowledged">>), 710: % %% THEN 711: %% Alice has 0 unread messages because she was the sender 712: check_inbox(Alice, [#conv{unread = 0, from = AliceRoomJid, 713: to = AliceJid, content = Msg}]), 714: %% Bob still has unread message 715: check_inbox(Bob, [#conv{unread = 1, from = AliceRoomJid, 716: to = BobJid, content = Msg}]), 717: %% Kate still has unread message 718: check_inbox(Kate, [#conv{unread = 1, from = AliceRoomJid, 719: to = KateJid, content = Msg}]) 720: end). 721: 722: groupchat_reset_stanza_resets_inbox(Config) -> 723: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 724: % %% WITH 725: AliceJid = inbox_helper:to_bare_lower(Alice), 726: BobJid = inbox_helper:to_bare_lower(Bob), 727: KateJid = inbox_helper:to_bare_lower(Kate), 728: Room = inbox_helper:create_room(Alice, [Bob, Kate]), 729: RoomJid = room_bin_jid(Room), 730: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 731: % %% WHEN A MESSAGE IS SENT 732: MsgStanza = escalus_stanza:set_id( 733: escalus_stanza:groupchat_to(RoomJid, <<"marker time!">>), <<"some_ID">>), 734: escalus:send(Alice, MsgStanza), 735: inbox_helper:wait_for_groupchat_msg([Alice, Bob, Kate]), 736: % verify that Bob has the message on inbox 737: check_inbox(Bob, [#conv{unread = 1, from = AliceRoomJid, 738: to = BobJid, content = <<"marker time!">>}]), 739: % %% AND WHEN SEND RESET FOR ROOM 740: inbox_helper:reset_inbox(Bob, RoomJid), 741: % %% THEN INBOX IS RESET FOR BOB, WITHOUT FORWARDING 742: %% Bob has 0 unread messages because he reset his counter 743: check_inbox(Bob, [#conv{unread = 0, from = AliceRoomJid, 744: to = BobJid, content = <<"marker time!">>}]), 745: %% Alice has 0 unread messages because she was the sender 746: check_inbox(Alice, [#conv{unread = 0, from = AliceRoomJid, 747: to = AliceJid, content = <<"marker time!">>}]), 748: %% Kate still has unread message 749: check_inbox(Kate, [#conv{unread = 1, from = AliceRoomJid, 750: to = KateJid, content = <<"marker time!">>}]), 751: %% And nobody received any other stanza 752: inbox_helper:assert_has_no_stanzas([Alice, Bob, Kate]) 753: end). 754: 755: %% this test combines options: 756: %% ... 757: %%{aff_changes, true}, 758: %%{remove_on_kicked, true}, 759: create_groupchat(Config) -> 760: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 761: RoomNode = <<"bobroom">>, 762: inbox_helper:create_room_and_check_inbox(Bob, [Alice, Kate], RoomNode) 763: end). 764: 765: 766: %% this test combines options: 767: %% ... 768: %%{aff_changes, false}, 769: %%{remove_on_kicked, true}, 770: create_groupchat_no_affiliation_stored(Config) -> 771: escalus:story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 772: InitOccupants = [{Alice, member}, {Kate, member}], 773: FinalOccupants = [{Bob, owner} | InitOccupants], 774: Msg = <<"Hi all!">>, 775: Users = [Alice, Bob, Kate], 776: InitConfig = [{<<"roomname">>, <<"Bob's room2">>}], 777: RoomNode = <<"bobroom2">>, 778: RoomJid = room_bin_jid(RoomNode), 779: AliceJid = inbox_helper:to_bare_lower(Alice), 780: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 781: BobJid = inbox_helper:to_bare_lower(Bob), 782: KateJid = inbox_helper:to_bare_lower(Kate), 783: %% Bob creates room 784: escalus:send(Bob, muc_light_helper:stanza_create_room(RoomNode, InitConfig, InitOccupants)), 785: muc_light_helper:verify_aff_bcast(FinalOccupants, FinalOccupants), 786: escalus:assert(is_iq_result, escalus:wait_for_stanza(Bob)), 787: %% affiliation change messages are not stored in inbox 788: [ check_inbox(User, []) || User <- Users ], 789: Stanza = escalus_stanza:set_id( 790: escalus_stanza:groupchat_to(RoomJid, Msg), <<"123">>), 791: %% Alice sends a message 792: escalus:send(Alice, Stanza), 793: inbox_helper:wait_for_groupchat_msg(Users), 794: %% Alice has 0 unread because she sent the last message 795: check_inbox(Alice, [#conv{unread = 0, from = AliceRoomJid, to = AliceJid, content = Msg}]), 796: %% Bob and Kate have one unread message 797: check_inbox(Bob, [#conv{unread = 1, from = AliceRoomJid, to = BobJid, content = Msg}]), 798: check_inbox(Kate, [#conv{unread = 1, from = AliceRoomJid, to = KateJid, content = Msg}]) 799: end). 800: 801: 802: %% this test combines options: 803: %% ... 804: %%{aff_changes, true}, 805: %%{remove_on_kicked, true}, 806: leave_and_remove_conversation(Config) -> 807: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 808: Msg = <<"Hi Room!">>, 809: Id = <<"MyID">>, 810: Users = [Alice, Bob, Kate], 811: AliceJid = inbox_helper:to_bare_lower(Alice), 812: KateJid = inbox_helper:to_bare_lower(Kate), 813: Room = inbox_helper:create_room(Alice, [Bob, Kate]), 814: RoomJid = room_bin_jid(Room), 815: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 816: Stanza = escalus_stanza:set_id( 817: escalus_stanza:groupchat_to(RoomJid, Msg), Id), 818: %% Alice sends msg to room 819: escalus:send(Alice, Stanza), 820: inbox_helper:wait_for_groupchat_msg(Users), 821: %% Bob leaves the room 822: muc_light_helper:user_leave(Room, Bob, [{Alice, owner}, {Kate, member}]), 823: %% Alice and Kate have one message 824: check_inbox(Alice, [#conv{unread = 0, from = AliceRoomJid, to = AliceJid, content = Msg}]), 825: check_inbox(Kate, [#conv{unread = 1, from = AliceRoomJid, to = KateJid, content = Msg}]), 826: %% Bob doesn't have conversation in his inbox 827: check_inbox(Bob, []) 828: end). 829: 830: %% this test combines options: 831: %% ... 832: %%{aff_changes, true}, 833: %%{remove_on_kicked, false}, 834: leave_and_store_conversation(Config) -> 835: escalus:story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 836: RoomName = <<"kicking-room">>, 837: AliceJid = inbox_helper:to_bare_lower(Alice), 838: BobJid = inbox_helper:to_bare_lower(Bob), 839: KateJid = inbox_helper:to_bare_lower(Kate), 840: RoomJid = room_bin_jid(RoomName), 841: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 842: Msg = <<"Hi all">>, 843: %% Alice creates a room and send msg 844: inbox_helper:create_room_send_msg_check_inbox(Alice, [Bob, Kate], RoomName, 845: Msg, <<"leave-id">>), 846: %% Bob leaves room 847: muc_light_helper:user_leave(RoomName, Bob, [{Alice, owner}, {Kate, member}]), 848: %% Alice and Kate have conversation 849: check_inbox(Alice, [#conv{unread = 0, from = AliceRoomJid, to = AliceJid, content = Msg}]), 850: check_inbox(Kate, [#conv{unread = 1, from = AliceRoomJid, to = KateJid, content = Msg}]), 851: %% Bob still has a conversation in inbox. Two unread - first is invitation, 852: %% the second is the leaving affiliation 853: check_inbox(Bob, [#conv{unread = 2, from = RoomJid, to = BobJid, 854: verify = fun inbox_helper:verify_is_none_aff_change/2}]) 855: end). 856: 857: %% this test combines options: 858: %% ... 859: %%{aff_changes, false}, 860: %%{remove_on_kicked, true}, 861: no_aff_stored_and_remove_on_kicked(Config) -> 862: escalus:story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 863: AliceJid = inbox_helper:to_bare_lower(Alice), 864: KateJid = inbox_helper:to_bare_lower(Kate), 865: RoomJid = room_bin_jid(?ROOM3), 866: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 867: Msg = <<"Hi all">>, 868: Users = [Alice, Bob, Kate], 869: Stanza = escalus_stanza:set_id( 870: escalus_stanza:groupchat_to(RoomJid, Msg), <<"33">>), 871: %% Alice sends a message 872: escalus:send(Alice, Stanza), 873: inbox_helper:wait_for_groupchat_msg(Users), 874: %% Bob leaves the room 875: muc_light_helper:user_leave(?ROOM3, Bob, [{Alice, owner}, {Kate, member}]), 876: %% Alice and Kate have message in groupchats 877: check_inbox(Alice, [#conv{unread = 0, from = AliceRoomJid, to = AliceJid, content = Msg}]), 878: check_inbox(Kate, [#conv{unread = 1, from = AliceRoomJid, to = KateJid, content = Msg}]), 879: %% Bob doesnt have a conversation in inbox 880: check_inbox(Bob, []) 881: end). 882: 883: 884: %% this test combines options: 885: %% ... 886: %%{aff_changes, true}, 887: %%{remove_on_kicked, false}, 888: no_stored_and_remain_after_kicked(Config) -> 889: escalus:story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 890: AliceJid = inbox_helper:to_bare_lower(Alice), 891: KateJid = inbox_helper:to_bare_lower(Kate), 892: BobJid = inbox_helper:to_bare_lower(Bob), 893: RoomJid = room_bin_jid(?ROOM4), 894: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 895: Msg = <<"Hi all">>, 896: Users = [Alice, Bob, Kate], 897: Stanza = escalus_stanza:set_id( 898: escalus_stanza:groupchat_to(RoomJid, Msg), <<"33">>), 899: %% Alice sends a message 900: escalus:send(Alice, Stanza), 901: inbox_helper:wait_for_groupchat_msg(Users), 902: %% Bob leaves the room 903: muc_light_helper:user_leave(?ROOM4, Bob, [{Alice, owner}, {Kate, member}]), 904: %% Alice and Kate have message in groupchats 905: check_inbox(Alice, [#conv{unread = 0, from = AliceRoomJid, to = AliceJid, content = Msg}]), 906: check_inbox(Kate, [#conv{unread = 1, from = AliceRoomJid, to = KateJid, content = Msg}]), 907: %% Bob have a conversation in inbox. First unread is message from Alice, the second the affiliation change 908: check_inbox(Bob, [#conv{ unread = 2, from = RoomJid, to = BobJid, 909: verify = fun inbox_helper:verify_is_none_aff_change/2}]) 910: end). 911: 912: 913: groupchat_markers_one_reset_room_created(Config) -> 914: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 915: Msg = <<"Welcome guys">>, 916: RoomName = <<"markers_room">>, 917: RoomJid = room_bin_jid(RoomName), 918: AliceJid = inbox_helper:to_bare_lower(Alice), 919: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 920: BobJid = inbox_helper:to_bare_lower(Bob), 921: KateJid = inbox_helper:to_bare_lower(Kate), 922: inbox_helper:create_room_send_msg_check_inbox(Alice, [Bob, Kate], RoomName, Msg, <<"1-id">>), 923: %% Now Bob sends marker 924: inbox_helper:mark_last_muclight_message(Bob, [Alice, Bob, Kate]), 925: %% The crew ask for inbox second time. Only Kate has unread messages 926: check_inbox(Alice,[#conv{unread = 0, from = AliceRoomJid, to = AliceJid, content = Msg}]), 927: check_inbox(Kate, [#conv{unread = 1, from = AliceRoomJid, to = KateJid, content = Msg}]), 928: check_inbox(Bob, [#conv{unread = 0, from = AliceRoomJid, to = BobJid, content = Msg}]) 929: end). 930: 931: groupchat_markers_all_reset_room_created(Config) -> 932: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 933: RoomName = <<"markers_room2">>, 934: AliceJid = inbox_helper:to_bare_lower(Alice), 935: RoomJid = room_bin_jid(RoomName), 936: AliceRoomJid = <<RoomJid/binary, "/", AliceJid/binary>>, 937: Msg = <<"Mark me!">>, 938: inbox_helper:create_room_send_msg_check_inbox(Alice, [Bob, Kate], RoomName, Msg, <<"2-id">>), 939: [inbox_helper:mark_last_muclight_message(U, [Alice, Bob, Kate]) || U <- [Bob, Kate]], 940: inbox_helper:foreach_check_inbox([Bob, Kate, Alice], 0, AliceRoomJid, Msg) 941: end). 942: 943: inbox_does_not_trigger_does_user_exist(Config) -> 944: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 945: Msg = <<"Mark me!">>, 946: RoomName = inbox_helper:create_room(Alice, [Bob, Kate]), 947: RoomJid = room_bin_jid(RoomName), 948: HookHandlerExtra = start_hook_listener(), 949: Stanza = escalus_stanza:groupchat_to(RoomJid, Msg), 950: %% Alice sends message to a room 951: escalus:send(Alice, Stanza), 952: [escalus:wait_for_stanza(User) || User <- [Alice, Bob, Kate]], 953: stop_hook_listener(HookHandlerExtra), 954: verify_hook_listener(RoomName) 955: end). 956: 957: system_message_is_correctly_avoided(Config) -> 958: escalus:story(Config, [{alice, 1}, {alice_bis, 1}, {bob, 1}], fun(Alice, AliceBis, Bob) -> 959: %% Variables 960: Id1 = <<"id-1">>, 961: Id2 = <<"id-2">>, 962: Msg1 = <<"Hi Room!">>, 963: Msg2 = <<"How are you?">>, 964: Users = [Alice, AliceBis, Bob], 965: InitOccupants = [{M, member} || M <- [AliceBis, Bob]], 966: Room = atom_to_binary(?FUNCTION_NAME, utf8), 967: BobJid = inbox_helper:to_bare_lower(Bob), 968: AliceJid = inbox_helper:to_bare_lower(Alice), 969: AliceBisJid = inbox_helper:to_bare_lower(AliceBis), 970: RoomJid = room_bin_jid(Room), 971: %% Given a room 972: muc_light_helper:given_muc_light_room(Room, Alice, InitOccupants), 973: BobRoomJid = <<RoomJid/binary, "/", BobJid/binary>>, 974: Stanza1 = escalus_stanza:set_id(escalus_stanza:groupchat_to(RoomJid, Msg1), Id1), 975: %% Alice sends msg to room 976: escalus:send(Alice, Stanza1), 977: inbox_helper:wait_for_groupchat_msg(Users), 978: %% Bob sends second message 979: Stanza2 = escalus_stanza:set_id(escalus_stanza:groupchat_to(RoomJid, Msg2), Id2), 980: escalus:send(Bob, Stanza2), 981: inbox_helper:wait_for_groupchat_msg(Users), 982: %% Alice has one unread message (from Bob) 983: check_inbox(Alice, [#conv{unread = 1, from = BobRoomJid, to = AliceJid, content = Msg2}]), 984: %% Bob has 0 unread messages because he sent the last message 985: check_inbox(Bob, [#conv{unread = 0, from = BobRoomJid, to = BobJid, content = Msg2}]), 986: %% AliceBis has 2 unread messages (from Alice and Bob) and does not have the affiliation 987: check_inbox(AliceBis, [#conv{unread = 2, from = BobRoomJid, to = AliceBisJid, content = Msg2}]) 988: end). 989: 990: %%-------------------------------------------------------------------- 991: %% Classic MUC tests 992: %%-------------------------------------------------------------------- 993: 994: simple_groupchat_stored_in_all_inbox_muc(Config) -> 995: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 996: RoomConfig = muc_helper:start_room(Config, extract_user_specs(Alice), muc_helper:fresh_room_name(), <<"some_friendly_name">>, default), 997: Users = [Alice, Bob, Kate], 998: Msg = <<"Hi Room!">>, 999: Id = <<"MyID">>, 1000: Room = ?config(room, RoomConfig), 1001: RoomAddr = muc_helper:room_address(Room), 1002: 1003: inbox_helper:enter_room(Room, Users), 1004: inbox_helper:make_members(Room, Alice, Users -- [Alice]), 1005: Stanza = escalus_stanza:set_id( 1006: escalus_stanza:groupchat_to(RoomAddr, Msg), Id), 1007: escalus:send(Bob, Stanza), 1008: inbox_helper:wait_for_groupchat_msg(Users), 1009: [AliceJid, BobJid, KateJid] = lists:map(fun inbox_helper:to_bare_lower/1, Users), 1010: BobRoomJid = muc_helper:room_address(Room, inbox_helper:nick(Bob)), 1011: %% Bob has 0 unread messages 1012: check_inbox(Bob, [#conv{unread = 0, from = BobRoomJid, to = BobJid, content = Msg}], 1013: #{}, #{case_sensitive => true}), 1014: %% Alice and Kate have one conv with 1 unread message 1015: check_inbox(Alice,[#conv{unread = 1, from = BobRoomJid, to = AliceJid, content = Msg}], 1016: #{}, #{case_sensitive => true}), 1017: check_inbox(Kate, [#conv{unread = 1, from = BobRoomJid, to = KateJid, content = Msg}], 1018: #{}, #{case_sensitive => true}) 1019: end). 1020: 1021: simple_groupchat_stored_in_offline_users_inbox_muc(Config) -> 1022: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 1023: RoomConfig = muc_helper:start_room(Config, extract_user_specs(Alice), muc_helper:fresh_room_name(), <<"some_friendly_name">>, default), 1024: Users = [Alice, Bob, Kate], 1025: Msg = <<"Hi Room!">>, 1026: Id = <<"MyID">>, 1027: Room = ?config(room, RoomConfig), 1028: RoomAddr = muc_helper:room_address(Room), 1029: 1030: inbox_helper:enter_room(Room, Users), 1031: inbox_helper:make_members(Room, Alice, Users -- [Alice]), 1032: inbox_helper:leave_room(Kate, Room, Users), 1033: Stanza = escalus_stanza:set_id( 1034: escalus_stanza:groupchat_to(RoomAddr, Msg), Id), 1035: escalus:send(Bob, Stanza), 1036: inbox_helper:wait_for_groupchat_msg(Users -- [Kate]), 1037: 1038: [AliceJid, BobJid, KateJid] = lists:map(fun inbox_helper:to_bare_lower/1, Users), 1039: BobRoomJid = muc_helper:room_address(Room, inbox_helper:nick(Bob)), 1040: %% Bob has 0 unread messages 1041: check_inbox(Bob, [#conv{unread = 0, from = BobRoomJid, to = BobJid, content = Msg}], 1042: #{}, #{case_sensitive => true}), 1043: %% Alice and Kate have one conv with 1 unread message 1044: check_inbox(Alice, [#conv{unread = 1, from = BobRoomJid, to = AliceJid, content = Msg}], 1045: #{}, #{case_sensitive => true}), 1046: check_inbox(Kate, [#conv{unread = 1, from = BobRoomJid, to = KateJid, content = Msg}], 1047: #{}, #{case_sensitive => true}) 1048: end). 1049: 1050: 1051: unread_count_is_the_same_after_going_online_again(Config) -> 1052: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 1053: RoomConfig = muc_helper:start_room(Config, extract_user_specs(Alice), muc_helper:fresh_room_name(), <<"some_friendly_name">>, default), 1054: Users = [Alice, Bob, Kate], 1055: Msg = <<"Hi Room!">>, 1056: Id = <<"MyID">>, 1057: Room = ?config(room, RoomConfig), 1058: RoomAddr = muc_helper:room_address(Room), 1059: 1060: inbox_helper:enter_room(Room, Users), 1061: inbox_helper:make_members(Room, Alice, Users -- [Alice]), 1062: inbox_helper:leave_room(Kate, Room, Users), 1063: Stanza = escalus_stanza:set_id( 1064: escalus_stanza:groupchat_to(RoomAddr, Msg), Id), 1065: escalus:send(Bob, Stanza), 1066: inbox_helper:wait_for_groupchat_msg(Users -- [Kate]), 1067: inbox_helper:enter_room(Room, Kate, Users -- [Kate], 1), 1068: [AliceJid, BobJid, KateJid] = lists:map(fun inbox_helper:to_bare_lower/1, Users), 1069: BobRoomJid = muc_helper:room_address(Room, inbox_helper:nick(Bob)), 1070: %% Bob has 0 unread messages 1071: check_inbox(Bob, [#conv{unread = 0, from = BobRoomJid, to = BobJid, content = Msg}], 1072: #{}, #{case_sensitive => true}), 1073: %% Alice and Kate have one conv with 1 unread message 1074: check_inbox(Alice, [#conv{unread = 1, from = BobRoomJid, to = AliceJid, content = Msg}], 1075: #{}, #{case_sensitive => true}), 1076: check_inbox(Kate, [#conv{unread = 1, from = BobRoomJid, to = KateJid, content = Msg}], 1077: #{}, #{case_sensitive => true}) 1078: end). 1079: 1080: unread_count_is_reset_after_sending_chatmarker(Config) -> 1081: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 1082: RoomConfig = muc_helper:start_room(Config, extract_user_specs(Alice), muc_helper:fresh_room_name(), <<"some_friendly_name">>, default), 1083: Users = [Alice, Bob, Kate], 1084: Msg = <<"Hi Room!">>, 1085: Id = <<"MyID">>, 1086: Room = ?config(room, RoomConfig), 1087: RoomAddr = muc_helper:room_address(Room), 1088: 1089: inbox_helper:enter_room(Room, Users), 1090: inbox_helper:make_members(Room, Alice, Users -- [Alice]), 1091: Stanza = escalus_stanza:set_id( 1092: escalus_stanza:groupchat_to(RoomAddr, Msg), Id), 1093: escalus:send(Bob, Stanza), 1094: inbox_helper:wait_for_groupchat_msg(Users), 1095: ChatMarkerWOType = escalus_stanza:chat_marker(RoomAddr, <<"displayed">>, Id), 1096: ChatMarker = escalus_stanza:setattr(ChatMarkerWOType, <<"type">>, <<"groupchat">>), 1097: %% User marks last message 1098: escalus:send(Kate, ChatMarker), 1099: inbox_helper:wait_for_groupchat_msg(Users), 1100: 1101: [AliceJid, BobJid, KateJid] = lists:map(fun inbox_helper:to_bare_lower/1, Users), 1102: BobRoomJid = muc_helper:room_address(Room, inbox_helper:nick(Bob)), 1103: %% Bob has 0 unread messages 1104: check_inbox(Bob, [#conv{unread = 0, from = BobRoomJid, to = BobJid, content = Msg}], 1105: #{}, #{case_sensitive => true}), 1106: %% Alice have one conv with 1 unread message 1107: check_inbox(Alice, [#conv{unread = 1, from = BobRoomJid, to = AliceJid, content = Msg}], 1108: #{}, #{case_sensitive => true}), 1109: %% Kate has 0 unread messages 1110: check_inbox(Kate, [#conv{unread = 0, from = BobRoomJid, to = KateJid, content = Msg}], 1111: #{}, #{case_sensitive => true}) 1112: end). 1113: 1114: non_reset_marker_should_not_affect_muc_inbox(Config) -> 1115: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 1116: RoomConfig = muc_helper:start_room(Config, extract_user_specs(Alice), muc_helper:fresh_room_name(), <<"some_friendly_name">>, default), 1117: % %% GIVEN 1118: Users = [Alice, Bob, Kate], 1119: Msg = <<"Hi Room!">>, 1120: Id = <<"MyID">>, 1121: Room = ?config(room, RoomConfig), 1122: RoomAddr = muc_helper:room_address(Room), 1123: 1124: % %% WHEN 1125: inbox_helper:enter_room(Room, Users), 1126: inbox_helper:make_members(Room, Alice, Users -- [Alice]), 1127: Stanza = escalus_stanza:set_id(escalus_stanza:groupchat_to(RoomAddr, Msg), Id), 1128: escalus:send(Bob, Stanza), 1129: inbox_helper:wait_for_groupchat_msg(Users), 1130: % %% AND MARKED WRONG 1131: KateChatMarkerWOType = escalus_stanza:chat_marker(RoomAddr,<<"acknowledged">>, Id), 1132: KateChatMarker = escalus_stanza:setattr(KateChatMarkerWOType, <<"type">>, <<"groupchat">>), 1133: escalus:send(Kate, KateChatMarker), 1134: inbox_helper:wait_for_groupchat_msg(Users), 1135: 1136: [AliceJid, BobJid, KateJid] = lists:map(fun inbox_helper:to_bare_lower/1, Users), 1137: BobRoomJid = muc_helper:room_address(Room, inbox_helper:nick(Bob)), 1138: % %% THEN 1139: %% Bob has 0 unread messages 1140: check_inbox(Bob, [#conv{unread = 0, from = BobRoomJid, to = BobJid, content = Msg}], 1141: #{}, #{case_sensitive => true}), 1142: %% Alice have one conv with 1 unread message 1143: check_inbox(Alice, [#conv{unread = 1, from = BobRoomJid, to = AliceJid, content = Msg}], 1144: #{}, #{case_sensitive => true}), 1145: %% Kate has 1 unread messages 1146: check_inbox(Kate, [#conv{unread = 1, from = BobRoomJid, to = KateJid, content = Msg}], 1147: #{}, #{case_sensitive => true}) 1148: end). 1149: 1150: unread_count_is_reset_after_sending_reset_stanza(Config) -> 1151: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 1152: RoomConfig = muc_helper:start_room(Config, extract_user_specs(Alice), muc_helper:fresh_room_name(), <<"some_friendly_name">>, default), 1153: % %% WITH 1154: Users = [Alice, Bob, Kate], 1155: Msg = <<"Hi Room!">>, 1156: Id = <<"MyID">>, 1157: Room = ?config(room, RoomConfig), 1158: RoomAddr = muc_helper:room_address(Room), 1159: % %% PROVIDED 1160: inbox_helper:enter_room(Room, Users), 1161: inbox_helper:make_members(Room, Alice, Users -- [Alice]), 1162: % %% WHEN A MESSAGE IS SENT 1163: Stanza = escalus_stanza:set_id( 1164: escalus_stanza:groupchat_to(RoomAddr, Msg), Id), 1165: escalus:send(Bob, Stanza), 1166: inbox_helper:wait_for_groupchat_msg(Users), 1167: [AliceJid, BobJid, KateJid] = lists:map(fun inbox_helper:to_bare_lower/1, Users), 1168: BobRoomJid = muc_helper:room_address(Room, inbox_helper:nick(Bob)), 1169: %% Make sure Kate gets her inbox updated 1170: check_inbox(Kate, [#conv{unread = 1, from = BobRoomJid, to = KateJid, content = Msg}], 1171: #{}, #{case_sensitive => true}), 1172: % %% AND WHEN SEND RESET FOR ROOM 1173: inbox_helper:reset_inbox(Kate, RoomAddr), 1174: 1175: %% Bob has 0 unread messages 1176: check_inbox(Bob, [#conv{unread = 0, from = BobRoomJid, to = BobJid, content = Msg}], 1177: #{}, #{case_sensitive => true}), 1178: %% Alice have one conv with 1 unread message 1179: check_inbox(Alice, [#conv{unread = 1, from = BobRoomJid, to = AliceJid, content = Msg}], 1180: #{}, #{case_sensitive => true}), 1181: %% Kate has 0 unread messages 1182: check_inbox(Kate, [#conv{unread = 0, from = BobRoomJid, to = KateJid, content = Msg}], 1183: #{}, #{case_sensitive => true}), 1184: inbox_helper:assert_has_no_stanzas([Alice, Bob, Kate]) 1185: end). 1186: 1187: private_messages_are_handled_as_one2one(Config) -> 1188: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 1189: RoomConfig = muc_helper:start_room(Config, extract_user_specs(Alice), muc_helper:fresh_room_name(), <<"some_friendly_name">>, default), 1190: Users = [Alice, Bob, Kate], 1191: Msg = <<"Hi Room!">>, 1192: Id = <<"MyID">>, 1193: Room = ?config(room, RoomConfig), 1194: BobRoomJid = muc_helper:room_address(Room, inbox_helper:nick(Bob)), 1195: KateRoomJid = muc_helper:room_address(Room, inbox_helper:nick(Kate)), 1196: 1197: inbox_helper:enter_room(Room, Users), 1198: inbox_helper:make_members(Room, Alice, Users -- [Alice]), 1199: Stanza = escalus_stanza:set_id( 1200: escalus_stanza:chat_to(BobRoomJid, Msg), Id), 1201: escalus:send(Kate, Stanza), 1202: _BobsPrivMsg = escalus:wait_for_stanza(Bob), 1203: 1204: KateJid = inbox_helper:to_bare_lower(Kate), 1205: %% Bob has 1 unread message 1206: check_inbox(Bob, [#conv{unread = 1, from = KateRoomJid, to = BobRoomJid, content = Msg}], 1207: #{}, #{case_sensitive => true}), 1208: %% Alice gets nothing 1209: check_inbox(Alice, []), 1210: %% Kate has 1 conv with 0 unread messages 1211: check_inbox(Kate, [#conv{unread = 0, from = KateJid, to = BobRoomJid, content = Msg}], 1212: #{}, #{case_sensitive => true, check_resource => false}) 1213: end). 1214: 1215: %%-------------------------------------------------------------------- 1216: %% Timestamp-related tests 1217: %%-------------------------------------------------------------------- 1218: 1219: timestamp_is_updated_on_new_message(Config) -> 1220: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}], fun(Alice, Bob) -> 1221: Body1 = <<"Hello Bob">>, 1222: Body2 = <<"Are you there?">>, 1223: %% We capture the timestamp after the first message 1224: escalus:send(Alice, escalus_stanza:chat_to(Bob, Body1)), 1225: _M1 = escalus:wait_for_stanza(Bob), 1226: [Item1] = check_inbox(Bob, [#conv{unread = 1, from = Alice, to = Bob, content = Body1}]), 1227: TStamp1 = inbox_helper:timestamp_from_item(Item1), 1228: %% We capture the timestamp after the second message 1229: escalus:send(Alice, escalus_stanza:chat_to(Bob, Body2)), 1230: _M2 = escalus:wait_for_stanza(Bob), 1231: [Item2] = check_inbox(Bob, [#conv{unread = 2, from = Alice, to = Bob, content = Body2}]), 1232: TStamp2 = inbox_helper:timestamp_from_item(Item2), 1233: %% Timestamp after second message must be higher 1234: case TStamp2 > TStamp1 of 1235: true -> ok; 1236: false -> error(#{ type => timestamp_is_not_greater, 1237: item1 => Item1, 1238: item2 => Item2, 1239: tstamp1 => TStamp1, 1240: tstamp2 => TStamp2 }) 1241: end 1242: end). 1243: 1244: order_by_timestamp_ascending(Config) -> 1245: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 1246: #{ Alice := AliceConvs, Bob := BobConvs, Kate := KateConvs } = 1247: given_conversations_between(Alice, [Bob, Kate]), 1248: 1249: %% Alice has two conversations in her inbox (no unread messages) 1250: %% check_inbox will reverse conversation list automatically 1251: check_inbox(Alice, AliceConvs, #{ order => asc }, #{}), 1252: 1253: %% Kate has one conversation with one unread 1254: check_inbox(Kate, KateConvs), 1255: 1256: %% Bob has one conversation with one unread 1257: check_inbox(Bob, BobConvs) 1258: end). 1259: 1260: get_by_timestamp_range(Config) -> 1261: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 1262: #{ Alice := AliceConvs, time_before := TimeBefore } = 1263: given_conversations_between(Alice, [Bob, Kate]), 1264: 1265: ConvWithBob = lists:keyfind(Bob, #conv.to, AliceConvs), 1266: TimeAfterBob = ConvWithBob#conv.time_after, 1267: 1268: %% Between given timestamps we have only one conversation: with Bob 1269: check_inbox(Alice, [ConvWithBob], #{ start => TimeBefore, 'end' => TimeAfterBob }, #{}) 1270: end). 1271: 1272: get_with_start_timestamp(Config) -> 1273: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 1274: #{ Alice := AliceConvs } = 1275: given_conversations_between(Alice, [Bob, Kate]), 1276: 1277: ConvWithBob = lists:keyfind(Bob, #conv.to, AliceConvs), 1278: TimeAfterBob = ConvWithBob#conv.time_after, 1279: ConvWithKate = lists:keyfind(Kate, #conv.to, AliceConvs), 1280: 1281: %% After given timestamp we have only one conversation: with Kate 1282: check_inbox(Alice, [ConvWithKate], #{ start => TimeAfterBob }, #{}) 1283: end). 1284: 1285: get_with_end_timestamp(Config) -> 1286: escalus:fresh_story(Config, [{alice, 1}, {bob, 1}, {kate, 1}], fun(Alice, Bob, Kate) -> 1287: #{ Alice := AliceConvs } = 1288: given_conversations_between(Alice, [Bob, Kate]), 1289: 1290: ConvWithBob = lists:keyfind(Bob, #conv.to, AliceConvs), 1291: TimeAfterBob = ConvWithBob#conv.time_after, 1292: %% Before given timestamp we have only one conversation: with Bob 1293: %% TODO: Improve this test to store 3+ conversations in Alice's inbox 1294: check_inbox(Alice, [ConvWithBob], #{ 'end' => TimeAfterBob }, #{}) 1295: end). 1296: 1297: 1298: 1299: start_hook_listener() -> 1300: TestCasePid = self(), 1301: distributed_helper:rpc(distributed_helper:mim(), ?MODULE, rpc_start_hook_handler, [TestCasePid, domain_helper:host_type()]). 1302: 1303: stop_hook_listener(HookExtra) -> 1304: distributed_helper:rpc(distributed_helper:mim(), ?MODULE, rpc_stop_hook_handler, [HookExtra, domain_helper:host_type()]). 1305: 1306: rpc_start_hook_handler(TestCasePid, HostType) -> 1307: Extra = #{test_case_pid => TestCasePid}, 1308: gen_hook:add_handler(does_user_exist, HostType, fun ?MODULE:hook_handler_fn/3, Extra, 1), 1309: Extra. 1310: 1311: rpc_stop_hook_handler(HookExtra, HostType) -> 1312: gen_hook:delete_handler(does_user_exist, HostType, fun ?MODULE:hook_handler_fn/3, HookExtra, 1). 1313: 1314: hook_handler_fn(Acc, 1315: #{args := [_HostType, User, _Stored]} = _Params, 1316: #{test_case_pid := Pid} = _Extra) -> 1317: Pid ! {input, User#jid.user}, 1318: {ok, Acc}. 1319: 1320: verify_hook_listener(RoomName) -> 1321: receive 1322: {input, RoomName} -> 1323: ct:fail("does_user_exist was called with a room jid"); 1324: {input, _} -> 1325: verify_hook_listener(RoomName) 1326: after 100 -> 1327: ct:pal("OK") 1328: end.