1: -module(graphql_session_SUITE).
2:
3: -include_lib("eunit/include/eunit.hrl").
4:
5: -compile([export_all, nowarn_export_all]).
6:
7: -import(common_helper, [unprep/1]).
8: -import(distributed_helper, [mim/0, require_rpc_nodes/1, rpc/4]).
9: -import(domain_helper, [domain/0]).
10: -import(graphql_helper, [execute_user_command/5, execute_command/4, get_listener_port/1,
11: get_listener_config/1, get_ok_value/2, get_err_msg/1, get_unauthorized/1,
12: get_coercion_err_msg/1]).
13:
14: suite() ->
15: require_rpc_nodes([mim]) ++ escalus:suite().
16:
17: all() ->
18: [{group, user_session},
19: {group, admin_session},
20: {group, domain_admin_session}].
21:
22: groups() ->
23: [{user_session, [parallel], user_session_tests()},
24: {admin_session, [], [{group, admin_session_http}, {group, admin_session_cli}]},
25: {admin_session_http, [], admin_session_tests()},
26: {admin_session_cli, [], admin_session_tests()},
27: {domain_admin_session, [], domain_admin_session_tests()}].
28:
29: user_session_tests() ->
30: [user_list_resources,
31: user_count_resources,
32: user_sessions_info].
33:
34: admin_session_tests() ->
35: [admin_list_sessions,
36: admin_count_sessions,
37: admin_list_user_sessions,
38: admin_count_user_resources,
39: admin_get_user_resource,
40: admin_list_users_with_status,
41: admin_count_users_with_status,
42: admin_kick_user_session,
43: admin_kick_user,
44: admin_set_presence,
45: admin_set_presence_away,
46: admin_set_presence_unavailable].
47:
48: domain_admin_session_tests() ->
49: [domain_admin_list_sessions,
50: domain_admin_count_sessions,
51: admin_list_user_sessions,
52: domain_admin_list_user_sessions_no_permission,
53: admin_count_user_resources,
54: domain_admin_count_user_resources_no_permission,
55: admin_get_user_resource,
56: domain_admin_get_user_resource_no_permission,
57: domain_admin_list_users_with_status,
58: domain_admin_count_users_with_status,
59: admin_kick_user_session,
60: domain_admin_kick_user_session_no_permission,
61: domain_admin_kick_user_no_permission,
62: admin_set_presence,
63: admin_set_presence_away,
64: admin_set_presence_unavailable,
65: domain_admin_set_presence_no_permission].
66:
67: init_per_suite(Config) ->
68: Config1 = ejabberd_node_utils:init(mim(), Config),
69: Config2 = escalus:init_per_suite(Config1),
70: dynamic_modules:save_modules(domain_helper:host_type(), Config2).
71:
72: end_per_suite(Config) ->
73: dynamic_modules:restore_modules(Config),
74: escalus:end_per_suite(Config).
75:
76: init_per_group(admin_session, Config) ->
77: escalus:create_users(Config, escalus:get_users([alice, alice_bis, bob]));
78: init_per_group(admin_session_cli, Config) ->
79: graphql_helper:init_admin_handler(Config);
80: init_per_group(admin_session_http, Config) ->
81: graphql_helper:init_admin_cli(Config);
82: init_per_group(domain_admin_session, Config) ->
83: Config1 = graphql_helper:init_domain_admin_handler(Config),
84: case Config1 of
85: {skip, require_rdbms} ->
86: Config1;
87: _ ->
88: escalus:create_users(Config1, escalus:get_users([alice, alice_bis, bob]))
89: end;
90: init_per_group(user_session, Config) ->
91: graphql_helper:init_user(Config).
92:
93: end_per_group(admin_session, Config) ->
94: escalus:delete_users(Config, escalus:get_users([alice, alice_bis, bob]));
95: end_per_group(domain_admin_session, Config) ->
96: escalus:delete_users(Config, escalus:get_users([alice, alice_bis, bob])),
97: escalus_fresh:clean(),
98: graphql_helper:clean();
99: end_per_group(_GroupName, _Config) ->
100: escalus_fresh:clean(),
101: graphql_helper:clean().
102:
103: init_per_testcase(CaseName, Config) ->
104: escalus:init_per_testcase(CaseName, Config).
105:
106: end_per_testcase(CaseName, Config) ->
107: escalus:end_per_testcase(CaseName, Config).
108:
109: %% Test cases
110:
111: user_list_resources(Config) ->
112: escalus:fresh_story_with_config(Config, [{alice, 2}], fun user_list_resources_story/3).
113:
114: user_list_resources_story(Config, Alice, Alice2) ->
115: Result = user_list_resources(Alice, Config),
116: Path = [data, session, listResources],
117: ExpectedRes = [escalus_client:resource(Alice), escalus_client:resource(Alice2)],
118: ?assertMatch(ExpectedRes, lists:sort(get_ok_value(Path, Result))).
119:
120: user_count_resources(Config) ->
121: escalus:fresh_story_with_config(Config, [{alice, 3}], fun user_count_resources_story/4).
122:
123: user_count_resources_story(Config, Alice, _Alice2, _Alice3) ->
124: Result = user_count_resources(Alice, Config),
125: Path = [data, session, countResources],
126: ?assertEqual(3, get_ok_value(Path, Result)).
127:
128: user_sessions_info(Config) ->
129: escalus:fresh_story_with_config(Config, [{alice, 1}], fun user_sessions_info_story/2).
130:
131: user_sessions_info_story(Config, Alice) ->
132: Result = user_list_sessions(Alice, Config),
133: ExpectedUser = escalus_utils:jid_to_lower(escalus_client:full_jid(Alice)),
134: Path = [data, session, listSessions],
135: ?assertMatch([#{<<"user">> := ExpectedUser}], get_ok_value(Path, Result)).
136:
137:
138: domain_admin_list_sessions(Config) ->
139: escalus:fresh_story_with_config(Config, [{alice, 1}, {alice_bis, 1}, {bob, 1}],
140: fun domain_admin_list_sessions_story/4).
141:
142: domain_admin_list_sessions_story(Config, Alice, AliceB, _Bob) ->
143: Domain = escalus_client:server(Alice),
144: BisDomain = escalus_client:server(AliceB),
145: Path = [data, session, listSessions],
146: % List all sessions
147: Res = list_sessions(null, Config),
148: get_unauthorized(Res),
149: % List sessions for an external domain
150: Res2 = list_sessions(BisDomain, Config),
151: get_unauthorized(Res2),
152: % List sessions for local domain
153: Res3 = list_sessions(Domain, Config),
154: Sessions = get_ok_value(Path, Res3),
155: ?assertEqual(2, length(Sessions)).
156:
157: domain_admin_count_sessions(Config) ->
158: escalus:fresh_story_with_config(Config, [{alice, 1}, {alice_bis, 1}, {bob, 1}],
159: fun domain_admin_count_sessions_story/4).
160:
161: domain_admin_count_sessions_story(Config, Alice, AliceB, _Bob) ->
162: Domain = escalus_client:server(Alice),
163: BisDomain = escalus_client:server(AliceB),
164: Path = [data, session, countSessions],
165: % Count all sessions
166: Res = count_sessions(null, Config),
167: get_unauthorized(Res),
168: % Count sessions for an external domain
169: Res2 = count_sessions(BisDomain, Config),
170: get_unauthorized(Res2),
171: % Count sessions for local domain
172: Res3 = count_sessions(Domain, Config),
173: Number = get_ok_value(Path, Res3),
174: ?assertEqual(2, Number).
175:
176: domain_admin_list_user_sessions_no_permission(Config) ->
177: escalus:fresh_story_with_config(Config, [{alice_bis, 1}],
178: fun domain_admin_list_user_sessions_no_permission_story/2).
179:
180: domain_admin_list_user_sessions_no_permission_story(Config, AliceBis) ->
181: AliceBisJID = escalus_client:full_jid(AliceBis),
182: Res = list_user_sessions(AliceBisJID, Config),
183: get_unauthorized(Res).
184:
185: domain_admin_count_user_resources_no_permission(Config) ->
186: escalus:fresh_story_with_config(Config, [{alice_bis, 1}],
187: fun domain_admin_count_user_resources_story_no_permission/2).
188:
189: domain_admin_count_user_resources_story_no_permission(Config, AliceBis) ->
190: AliceBisJID = escalus_client:full_jid(AliceBis),
191: Res = count_user_resources(AliceBisJID, Config),
192: get_unauthorized(Res).
193:
194: domain_admin_get_user_resource_no_permission(Config) ->
195: escalus:fresh_story_with_config(Config, [{alice_bis, 1}],
196: fun domain_admin_get_user_resource_story_no_permission_story/2).
197:
198: domain_admin_get_user_resource_story_no_permission_story(Config, AliceBis) ->
199: AliceBisJID = escalus_client:short_jid(AliceBis),
200: Res = get_user_resource(AliceBisJID, 2, Config),
201: get_unauthorized(Res).
202:
203: domain_admin_kick_user_session_no_permission(Config) ->
204: escalus:fresh_story_with_config(Config, [{alice_bis, 1}],
205: fun domain_admin_kick_user_session_no_permission_story/2).
206:
207: domain_admin_kick_user_session_no_permission_story(Config, AliceBis) ->
208: AliceBisJID = escalus_client:full_jid(AliceBis),
209: Reason = <<"Test kick">>,
210: Res = kick_user_session(AliceBisJID, Reason, Config),
211: get_unauthorized(Res).
212:
213: domain_admin_kick_user_no_permission(Config) ->
214: escalus:fresh_story_with_config(Config, [{alice_bis, 1}],
215: fun domain_admin_kick_user_no_permission_story/2).
216:
217: domain_admin_kick_user_no_permission_story(Config, AliceBis) ->
218: AliceBisJID = escalus_client:short_jid(AliceBis),
219: Reason = <<"Test kick">>,
220: Res = kick_user(AliceBisJID, Reason, Config),
221: get_unauthorized(Res).
222:
223: domain_admin_set_presence_no_permission(Config) ->
224: escalus:fresh_story_with_config(Config, [{alice_bis, 1}],
225: fun domain_admin_set_presence_no_permission_story/2).
226:
227: domain_admin_set_presence_no_permission_story(Config, AliceBis) ->
228: AliceBisJID = escalus_client:full_jid(AliceBis),
229: Type = <<"AVAILABLE">>,
230: Show = <<"ONLINE">>,
231: Status = <<"Be right back">>,
232: Priority = 1,
233: Res = set_presence(AliceBisJID, Type, Show, Status, Priority, Config),
234: get_unauthorized(Res).
235:
236: domain_admin_list_users_with_status(Config) ->
237: escalus:fresh_story_with_config(Config, [{alice, 1}, {alice_bis, 1}],
238: fun domain_admin_list_users_with_status_story/3).
239:
240: domain_admin_list_users_with_status_story(Config, Alice, _AliceB) ->
241: AliceJID = escalus_client:full_jid(Alice),
242: AwayStatus = <<"away">>,
243: AwayPresence = escalus_stanza:presence_show(AwayStatus),
244: DndStatus = <<"dnd">>,
245: DndPresence = escalus_stanza:presence_show(DndStatus),
246: % List users with away status globally
247: escalus_client:send(Alice, AwayPresence),
248: Res = list_users_with_status(null, AwayStatus, Config),
249: get_unauthorized(Res),
250: % List users with away status for a domain
251: assert_list_users_with_status([AliceJID], domain(), AwayStatus, Config),
252: assert_list_users_with_status([AliceJID], unprep(domain()), AwayStatus, Config),
253: % List users with away status for an external domain
254: Res3 = list_users_with_status(domain_helper:secondary_domain(), AwayStatus, Config),
255: get_unauthorized(Res3),
256: % List users with dnd status globally
257: escalus_client:send(Alice, DndPresence),
258: Res4 = list_users_with_status(null, DndStatus, Config),
259: get_unauthorized(Res4),
260: % List users with dnd status for a domain
261: assert_list_users_with_status([AliceJID], domain(), DndStatus, Config),
262: % List users with dnd status for an external domain
263: Res6 = list_users_with_status(domain_helper:secondary_domain(), AwayStatus, Config),
264: get_unauthorized(Res6).
265:
266: domain_admin_count_users_with_status(Config) ->
267: escalus:fresh_story_with_config(Config, [{alice, 1}, {alice_bis, 1}],
268: fun domain_admin_count_users_with_status_story/3).
269:
270: domain_admin_count_users_with_status_story(Config, Alice, _AliceB) ->
271: AwayStatus = <<"away">>,
272: AwayPresence = escalus_stanza:presence_show(AwayStatus),
273: DndStatus = <<"dnd">>,
274: DndPresence = escalus_stanza:presence_show(DndStatus),
275: % Count users with away status globally
276: escalus_client:send(Alice, AwayPresence),
277: Res = count_users_with_status(null, AwayStatus, Config),
278: get_unauthorized(Res),
279: % Count users with away status for a domain
280: assert_count_users_with_status(1, domain_helper:domain(), AwayStatus, Config),
281: assert_count_users_with_status(1, unprep(domain_helper:domain()), AwayStatus, Config),
282: % Count users with dnd status globally
283: escalus_client:send(Alice, DndPresence),
284: Res3 = count_users_with_status(null, DndStatus, Config),
285: get_unauthorized(Res3),
286: % Count users with dnd status for a domain
287: assert_count_users_with_status(1, domain_helper:domain(), DndStatus, Config).
288:
289: admin_list_sessions(Config) ->
290: escalus:fresh_story_with_config(Config, [{alice, 1}, {alice_bis, 1}, {bob, 1}],
291: fun admin_list_sessions_story/4).
292:
293: admin_list_sessions_story(Config, _Alice, AliceB, _Bob) ->
294: BisDomain = escalus_client:server(AliceB),
295: Path = [data, session, listSessions],
296: % List all sessions
297: Res = list_sessions(null, Config),
298: Sessions = get_ok_value(Path, Res),
299: ?assertEqual(3, length(Sessions)),
300: % List sessions for a domain
301: Res2 = list_sessions(BisDomain, Config),
302: Sessions2 = get_ok_value(Path, Res2),
303: ?assertEqual(1, length(Sessions2)),
304: Res3 = list_sessions(unprep(BisDomain), Config),
305: Sessions3 = get_ok_value(Path, Res3),
306: ?assertEqual(1, length(Sessions3)),
307: % List sessions for a non-existing domain
308: Res4 = list_sessions(<<"nonexisting">>, Config),
309: ?assertEqual(<<"Domain not found">>, get_err_msg(Res4)).
310:
311: admin_count_sessions(Config) ->
312: escalus:fresh_story_with_config(Config, [{alice, 1}, {alice_bis, 1}, {bob, 1}],
313: fun admin_count_sessions_story/4).
314:
315: admin_count_sessions_story(Config, _Alice, AliceB, _Bob) ->
316: BisDomain = escalus_client:server(AliceB),
317: Path = [data, session, countSessions],
318: % Count all sessions
319: Res = count_sessions(null, Config),
320: Number = get_ok_value(Path, Res),
321: ?assertEqual(3, Number),
322: % Count sessions for a domain
323: Res2 = count_sessions(BisDomain, Config),
324: ?assertEqual(1, get_ok_value(Path, Res2)),
325: Res3 = count_sessions(unprep(BisDomain), Config),
326: ?assertEqual(1, get_ok_value(Path, Res3)),
327: % Count sessions for a non-existing domain
328: Res4 = count_sessions(<<"nonexisting">>, Config),
329: ?assertEqual(<<"Domain not found">>, get_err_msg(Res4)).
330:
331: admin_list_user_sessions(Config) ->
332: escalus:fresh_story_with_config(Config, [{alice, 2}, {bob, 1}],
333: fun admin_list_user_sessions_story/4).
334:
335: admin_list_user_sessions_story(Config, Alice, Alice2, _Bob) ->
336: S1JID = escalus_client:full_jid(Alice),
337: S2JID = escalus_client:full_jid(Alice2),
338: Path = [data, session, listUserSessions],
339: Res = list_user_sessions(S1JID, Config),
340: ExpectedRes = lists:map(fun escalus_utils:jid_to_lower/1, [S1JID, S2JID]),
341: Sessions = get_ok_value(Path, Res),
342: ?assertEqual(2, length(Sessions)),
343: check_users(ExpectedRes, Sessions),
344: % Check for a non-existing user
345: Domain = domain(),
346: Res2 = list_user_sessions(<<"alien@", Domain/binary>>, Config),
347: ?assertEqual(<<"Given user does not exist">>, get_err_msg(Res2)).
348:
349: admin_count_user_resources(Config) ->
350: escalus:fresh_story_with_config(Config, [{alice, 3}], fun admin_count_user_resources_story/4).
351:
352: admin_count_user_resources_story(Config, Alice, _Alice2, _Alice3) ->
353: Path = [data, session, countUserResources],
354: JID = escalus_client:full_jid(Alice),
355: Res = count_user_resources(JID, Config),
356: ?assertEqual(3, get_ok_value(Path, Res)),
357: % Check for a non-existing user
358: Domain = domain(),
359: Res2 = count_user_resources(<<"alien@", Domain/binary>>, Config),
360: ?assertEqual(<<"Given user does not exist">>, get_err_msg(Res2)).
361:
362: admin_get_user_resource(Config) ->
363: escalus:fresh_story_with_config(Config, [{alice, 3}], fun admin_get_user_resource_story/4).
364:
365: admin_get_user_resource_story(Config, Alice, Alice2, _Alice3) ->
366: Path = [data, session, getUserResource],
367: JID = escalus_client:short_jid(Alice),
368: % Provide a correct resource number
369: Res = get_user_resource(JID, 2, Config),
370: ?assertEqual(escalus_client:resource(Alice2), get_ok_value(Path, Res)),
371: % Provide a wrong resource number
372: Res2 = get_user_resource(JID, 4, Config),
373: ?assertNotEqual(nomatch, binary:match(get_err_msg(Res2), <<"Wrong resource number">>)),
374: % Check for a non-existing user
375: Domain = domain(),
376: Res3 = get_user_resource(<<"alien@", Domain/binary>>, 1, Config),
377: ?assertEqual(<<"Given user does not exist">>, get_err_msg(Res3)).
378:
379: admin_count_users_with_status(Config) ->
380: escalus:fresh_story_with_config(Config, [{alice, 1}, {alice_bis, 1}],
381: fun admin_count_users_with_status_story/3).
382:
383: admin_count_users_with_status_story(Config, Alice, AliceB) ->
384: AwayStatus = <<"away">>,
385: AwayPresence = escalus_stanza:presence_show(AwayStatus),
386: DndStatus = <<"dnd">>,
387: DndPresence = escalus_stanza:presence_show(DndStatus),
388: % Count users with away status globally
389: escalus_client:send(Alice, AwayPresence),
390: escalus_client:send(AliceB, AwayPresence),
391: assert_count_users_with_status(2, null, AwayStatus, Config),
392: % Count users with away status for a domain
393: assert_count_users_with_status(1, domain_helper:domain(), AwayStatus, Config),
394: assert_count_users_with_status(1, unprep(domain_helper:domain()), AwayStatus, Config),
395: % Count users with dnd status globally
396: escalus_client:send(AliceB, DndPresence),
397: assert_count_users_with_status(1, null, DndStatus, Config),
398: % Count users with dnd status for a non-existing domain
399: Res = count_users_with_status(<<"nonexisting">>, DndStatus, Config),
400: ?assertEqual(<<"Domain not found">>, get_err_msg(Res)).
401:
402: admin_list_users_with_status(Config) ->
403: escalus:fresh_story_with_config(Config, [{alice, 1}, {alice_bis, 1}],
404: fun admin_list_users_with_status_story/3).
405:
406: admin_list_users_with_status_story(Config, Alice, AliceB) ->
407: AliceJID = escalus_client:full_jid(Alice),
408: AliceBJID = escalus_client:full_jid(AliceB),
409: AwayStatus = <<"away">>,
410: AwayPresence = escalus_stanza:presence_show(AwayStatus),
411: DndStatus = <<"dnd">>,
412: DndPresence = escalus_stanza:presence_show(DndStatus),
413: % List users with away status globally
414: escalus_client:send(Alice, AwayPresence),
415: escalus_client:send(AliceB, AwayPresence),
416: assert_list_users_with_status([AliceJID, AliceBJID], null, AwayStatus, Config),
417: % List users with away status for a domain
418: assert_list_users_with_status([AliceJID], domain(), AwayStatus, Config),
419: assert_list_users_with_status([AliceJID], unprep(domain()), AwayStatus, Config),
420: % List users with dnd status globally
421: escalus_client:send(AliceB, DndPresence),
422: assert_list_users_with_status([AliceBJID], null, DndStatus, Config),
423: % List users with dnd status for a non-existing domain
424: Res = count_users_with_status(<<"nonexisting">>, DndStatus, Config),
425: ?assertEqual(<<"Domain not found">>, get_err_msg(Res)).
426:
427: admin_kick_user_session(Config) ->
428: escalus:fresh_story_with_config(Config, [{alice, 2}], fun admin_kick_user_session_story/3).
429:
430: admin_kick_user_session_story(Config, Alice1, Alice2) ->
431: JIDA1 = escalus_client:full_jid(Alice1),
432: JIDA2 = escalus_client:full_jid(Alice2),
433: Reason = <<"Test kick">>,
434: Path = [data, session, kickUserSession, message],
435: Res = kick_user_session(JIDA1, Reason, Config),
436: % Kick an active session
437: ?assertNotEqual(nomatch, binary:match(get_ok_value(Path, Res), <<"kicked">>)),
438: ?assertEqual(JIDA1, get_ok_value([data, session, kickUserSession, jid], Res)),
439: % Try to kick an offline session
440: Res2 = kick_user_session(JIDA1, Reason, Config),
441: ?assertNotEqual(nomatch, binary:match(get_err_msg(Res2), <<"No active session">>)),
442: % Try to kick a session with JID without a resource
443: Res3 = kick_user_session(escalus_client:short_jid(Alice2), Reason, Config),
444: ?assertNotEqual(nomatch, binary:match(get_coercion_err_msg(Res3), <<"jid_without_resource">>)),
445: % Kick active session without reason text
446: Res4 = kick_user_session(JIDA2, null, Config),
447: ?assertNotEqual(nomatch, binary:match(get_ok_value(Path, Res4), <<"kicked">>)),
448: % Kick a non-existing user
449: Domain = domain(),
450: Res5 = kick_user_session(<<"alien@", Domain/binary, "/mobile">>, null, Config),
451: ?assertEqual(<<"Given user does not exist">>, get_err_msg(Res5)).
452:
453: admin_kick_user(Config) ->
454: escalus:fresh_story_with_config(Config, [{alice, 2}], fun admin_kick_user_story/3).
455:
456: admin_kick_user_story(Config, Alice1, _Alice2) ->
457: AliceJID = escalus_client:short_jid(Alice1),
458: Reason = <<"Test kick">>,
459: Res1 = kick_user(AliceJID, Reason, Config),
460: Res2 = get_ok_value([data, session, kickUser], Res1),
461: ?assertEqual(2, length(Res2)),
462: ?assertEqual([true, true], [Kicked || #{<<"kicked">> := Kicked} <- Res2]),
463: % Kick a non-existing user
464: Domain = domain(),
465: Res5 = kick_user(<<"alien@", Domain/binary>>, null, Config),
466: ?assertEqual(<<"Given user does not exist">>, get_err_msg(Res5)).
467:
468: admin_set_presence(Config) ->
469: escalus:fresh_story_with_config(Config, [{alice, 1}], fun admin_set_presence_story/2).
470:
471: admin_set_presence_story(Config, Alice) ->
472: JID = escalus_client:full_jid(Alice),
473: ShortJID = escalus_client:short_jid(Alice),
474: Type = <<"AVAILABLE">>,
475: Show = <<"ONLINE">>,
476: Status = <<"Be right back">>,
477: Priority = 1,
478: % Send short JID
479: Res = set_presence(ShortJID, Type, Show, Status, Priority, Config),
480: ?assertNotEqual(nomatch, binary:match(get_err_msg(Res), <<"resource is empty">>)),
481: % Non-existing user
482: Domain = domain(),
483: Res2 = set_presence(<<"alien@", Domain/binary, "/mobile">>, Type, Show, Status, Priority, Config),
484: ?assertEqual(<<"Given user does not exist">>, get_err_msg(Res2)),
485: % Send full JID
486: Path = [data, session, setPresence, message],
487: Res3 = set_presence(JID, Type, Show, Status, Priority, Config),
488: ?assertNotEqual(nomatch, binary:match(get_ok_value(Path, Res3), <<"set successfully">>)),
489: Presence = escalus:wait_for_stanza(Alice),
490: ?assertNot(escalus_pred:is_presence_with_show(<<"online">>, Presence)),
491: escalus:assert(is_presence_with_type, [<<"available">>], Presence),
492: escalus:assert(is_presence_with_status, [Status], Presence),
493: escalus:assert(is_presence_with_priority, [<<"1">>], Presence).
494:
495: admin_set_presence_away(Config) ->
496: escalus:fresh_story_with_config(Config, [{alice, 1}], fun admin_set_presence_away_story/2).
497:
498: admin_set_presence_away_story(Config, Alice) ->
499: JID = escalus_client:full_jid(Alice),
500: Type = <<"AVAILABLE">>,
501: Show = <<"AWAY">>,
502: Path = [data, session, setPresence, message],
503: Res2 = set_presence(JID, Type, Show, null, null, Config),
504: ?assertNotEqual(nomatch, binary:match(get_ok_value(Path, Res2), <<"set successfully">>)),
505: Presence = escalus:wait_for_stanza(Alice),
506: escalus:assert(is_presence_with_type, [<<"available">>], Presence),
507: escalus:assert(is_presence_with_show, [<<"away">>], Presence).
508:
509: admin_set_presence_unavailable(Config) ->
510: escalus:fresh_story_with_config(Config, [{alice, 2}], fun admin_set_presence_unavailable_story/3).
511:
512: admin_set_presence_unavailable_story(Config, Alice, Alice2) ->
513: JID = escalus_client:full_jid(Alice),
514: Type = <<"UNAVAILABLE">>,
515: Status = <<"I'm sleeping">>,
516: Path = [data, session, setPresence, message],
517: Res2 = set_presence(JID, Type, null, Status, null, Config),
518: ?assertNotEqual(nomatch, binary:match(get_ok_value(Path, Res2), <<"set successfully">>)),
519: Presence = escalus:wait_for_stanza(Alice2),
520: escalus:assert(is_presence_with_type, [<<"unavailable">>], Presence),
521: escalus:assert(is_presence_with_status, [Status], Presence).
522:
523:
524: %% Commands
525:
526: user_list_resources(User, Config) ->
527: execute_user_command(<<"session">>, <<"listResources">>, User, #{}, Config).
528:
529: user_count_resources(User, Config) ->
530: execute_user_command(<<"session">>, <<"countResources">>, User, #{}, Config).
531:
532: user_list_sessions(User, Config) ->
533: execute_user_command(<<"session">>, <<"listSessions">>, User, #{}, Config).
534:
535: list_sessions(Domain, Config) ->
536: Vars = #{<<"domain">> => Domain},
537: execute_command(<<"session">>, <<"listSessions">>, Vars, Config).
538:
539: count_sessions(Domain, Config) ->
540: Vars = #{<<"domain">> => Domain},
541: execute_command(<<"session">>, <<"countSessions">>, Vars, Config).
542:
543: list_user_sessions(User, Config) ->
544: Vars = #{<<"user">> => User},
545: execute_command(<<"session">>, <<"listUserSessions">>, Vars, Config).
546:
547: count_user_resources(User, Config) ->
548: Vars = #{<<"user">> => User},
549: execute_command(<<"session">>, <<"countUserResources">>, Vars, Config).
550:
551: get_user_resource(User, Number, Config) ->
552: Vars = #{<<"user">> => User, <<"number">> => Number},
553: execute_command(<<"session">>, <<"getUserResource">>, Vars, Config).
554:
555: list_users_with_status(Domain, Status, Config) ->
556: Vars = #{<<"domain">> => Domain, <<"status">> => Status},
557: execute_command(<<"session">>, <<"listUsersWithStatus">>, Vars, Config).
558:
559: count_users_with_status(Domain, Status, Config) ->
560: Vars = #{<<"domain">> => Domain, <<"status">> => Status},
561: execute_command(<<"session">>, <<"countUsersWithStatus">>, Vars, Config).
562:
563: kick_user_session(JID, Reason, Config) ->
564: Vars = #{<<"user">> => JID, <<"reason">> => Reason},
565: execute_command(<<"session">>, <<"kickUserSession">>, Vars, Config).
566:
567: kick_user(JID, Reason, Config) ->
568: Vars = #{<<"user">> => JID, <<"reason">> => Reason},
569: execute_command(<<"session">>, <<"kickUser">>, Vars, Config).
570:
571: set_presence(JID, Type, Show, Status, Priority, Config) ->
572: Vars = #{<<"user">> => JID, <<"type">> => Type, <<"show">> => Show,
573: <<"status">> => Status, <<"priority">> => Priority},
574: execute_command(<<"session">>, <<"setPresence">>, Vars, Config).
575:
576: %% Helpers
577:
578: assert_list_users_with_status(ExpectedUsers, Domain, Status, Config) ->
579: Res = list_users_with_status(Domain, Status, Config),
580: Users = get_ok_value([data, session, listUsersWithStatus], Res),
581: check_users(ExpectedUsers, Users).
582:
583: assert_count_users_with_status(ExpectedCount, Domain, Status, Config) ->
584: Res = count_users_with_status(Domain, Status, Config),
585: Count = get_ok_value([data, session, countUsersWithStatus], Res),
586: ?assertEqual(ExpectedCount, Count).
587:
588: -spec check_users([jid:literal_jid()], [#{user := jid:literal_jid()}]) -> boolean().
589: check_users(Expected, ActualUsers) ->
590: ActualJIDs = [JID || #{<<"user">> := JID} <- ActualUsers],
591: ?assertEqual(lists:sort(Expected), lists:sort(ActualJIDs)).