1: -module(mongoose_lazy_routing_SUITE).
2:
3: -compile([export_all, nowarn_export_all]).
4:
5: -include_lib("eunit/include/eunit.hrl").
6:
7: -define(assertEqualLists(L1, L2), ?assertEqual(lists:sort(L1), lists:sort(L2))).
8:
9: -define(HOST_TYPE_1, <<"host type #1">>).
10: -define(HOST_TYPE_2, <<"host type #2">>).
11:
12: -define(DOMAIN_1, <<"domain1.test">>).
13: -define(DOMAIN_2, <<"domain2.test">>).
14: -define(DOMAIN_3, <<"domain3.test">>).
15: -define(SUBDOMAIN_1, <<"sub.", (?DOMAIN_1)/binary>>).
16: -define(SUBDOMAIN_2, <<"sub.", (?DOMAIN_2)/binary>>).
17: -define(SUBDOMAIN_3, <<"sub.", (?DOMAIN_3)/binary>>).
18:
19: %% this domain is required for testing domain/subdomain conflict resolution.
20: -define(DOMAIN_X, <<"domain_x.test">>).
21:
22: %% required for handles_missing_domain_or_subdomain test case
23: -define(MISSING_DOMAIN, <<"missing.domain.test">>).
24: -define(MISSING_DOMAIN_2, <<"missing.domain2.test">>).
25:
26: -define(NAMESPACE_1, <<"dummy:namespace:1">>).
27: -define(NAMESPACE_2, <<"dummy:namespace:2">>).
28: -define(COMPONENT, dummy_component).
29:
30: -import(mongoose_lazy_routing, [maybe_add_domain_or_subdomain/1,
31: maybe_remove_domain/2,
32: maybe_remove_subdomain/1,
33: register_iq_handler_for_domain/4,
34: register_iq_handler_for_subdomain/5,
35: unregister_iq_handler_for_domain/3,
36: unregister_iq_handler_for_subdomain/4]).
37:
38: all() ->
39: [can_add_and_remove_domain_or_subdomain,
40: handles_missing_domain_or_subdomain,
41: registers_top_level_domain_in_case_domain_subdomain_conflicts,
42: can_register_and_unregister_iq_handler_for_two_domains,
43: can_add_domain_for_a_registered_iq_handler,
44: can_register_and_unregister_iq_handler_for_two_subdomains,
45: can_add_subdomain_for_a_registered_iq_handler,
46: handles_double_iq_handler_registration_deregistration_for_domain,
47: handles_double_iq_handler_registration_deregistration_for_subdomain].
48:
49: init_per_testcase(_, Config) ->
50: mongoose_lazy_routing:start_link(),
51: setup_meck(),
52: Config.
53:
54: end_per_testcase(_, Config) ->
55: meck:unload(),
56: Config.
57:
58: %%-------------------------------------------------------------------
59: %% test cases
60: %%-------------------------------------------------------------------
61: can_add_and_remove_domain_or_subdomain(_Config) ->
62: %% add 2 domains, one of them add twice
63: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_1)),
64: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_2)),
65: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_2)),
66: %% add 2 subdomains, one of them add twice
67: ?assertEqual(true, maybe_add_domain_or_subdomain(?SUBDOMAIN_1)),
68: ?assertEqual(true, maybe_add_domain_or_subdomain(?SUBDOMAIN_2)),
69: ?assertEqual(true, maybe_add_domain_or_subdomain(?SUBDOMAIN_2)),
70: %% check that 2 domains and 2 subdomains added properly
71: ?assertEqualLists([?DOMAIN_1, ?DOMAIN_2], get_all_registered_domains()),
72: ?assertEqualLists([{?SUBDOMAIN_1, packet_handler(?SUBDOMAIN_1)},
73: {?SUBDOMAIN_2, packet_handler(?SUBDOMAIN_2)}],
74: get_all_registered_subdomains()),
75: ?assertEqual([], get_all_unregistered_domains()),
76: ?assertEqual([], get_all_unregistered_subdomains()),
77: [meck:reset(M) || M <- [ejabberd_local, mongoose_router]],
78: %% remove 2 domains, one of them remove twice
79: maybe_remove_domain(domain_host_type(?DOMAIN_1), ?DOMAIN_1),
80: maybe_remove_domain(domain_host_type(?DOMAIN_2), ?DOMAIN_2),
81: maybe_remove_domain(domain_host_type(?DOMAIN_2), ?DOMAIN_2),
82: %% remove 2 subdomains, one of them remove twice
83: maybe_remove_subdomain(subdomain_info(?SUBDOMAIN_1)),
84: maybe_remove_subdomain(subdomain_info(?SUBDOMAIN_2)),
85: maybe_remove_subdomain(subdomain_info(?SUBDOMAIN_2)),
86: %% check that 2 domains and 2 subdomains removed properly
87: mongoose_lazy_routing:sync(),
88: ?assertEqualLists([], get_all_registered_domains()),
89: ?assertEqualLists([], get_all_registered_subdomains()),
90: ?assertEqual([?SUBDOMAIN_1, ?SUBDOMAIN_2], get_all_unregistered_subdomains()),
91: ?assertEqual([?DOMAIN_1, ?DOMAIN_2], get_all_unregistered_domains()).
92:
93: handles_missing_domain_or_subdomain(_Config) ->
94: %% ?MISSING_DOMAIN is used to emulate domain/subdomain removal
95: %% before mongoose_lazy_routing processes domain registration
96: ?assertEqual(false, maybe_add_domain_or_subdomain(?MISSING_DOMAIN)),
97: ?assertEqual(false, maybe_add_domain_or_subdomain(?MISSING_DOMAIN_2)),
98: ?assertEqual(1, meck:num_calls(mongoose_lazy_routing, handle_call,
99: [{maybe_add_domain_or_subdomain, ?MISSING_DOMAIN},
100: '_', '_'])),
101: ?assertEqual(0, meck:num_calls(mongoose_lazy_routing, handle_call,
102: [{maybe_add_domain_or_subdomain, ?MISSING_DOMAIN_2},
103: '_', '_'])).
104:
105: registers_top_level_domain_in_case_domain_subdomain_conflicts(_Config) ->
106: %% add 2 times domain which has name collision with subdomain
107: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_X)),
108: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_X)),
109: %% check that only top level domain is added
110: ?assertEqualLists([?DOMAIN_X], get_all_registered_domains()),
111: ?assertEqualLists([], get_all_registered_subdomains()),
112: ?assertEqual([], get_all_unregistered_domains()),
113: ?assertEqual([], get_all_unregistered_subdomains()),
114: [meck:reset(M) || M <- [ejabberd_local, mongoose_router]],
115: %% try to remove that domain and subdomain
116: maybe_remove_domain(domain_host_type(?DOMAIN_X), ?DOMAIN_X),
117: maybe_remove_subdomain(subdomain_info(?DOMAIN_X)),
118: mongoose_lazy_routing:sync(),
119: %% check that only top level domain is removed
120: ?assertEqualLists([], get_all_registered_domains()),
121: ?assertEqualLists([], get_all_registered_subdomains()),
122: ?assertEqual([], get_all_unregistered_subdomains()),
123: ?assertEqual([?DOMAIN_X], get_all_unregistered_domains()).
124:
125: can_register_and_unregister_iq_handler_for_two_domains(_Config) ->
126: %% add 2 domains for ?HOST_TYPE_2 and one subdomain (just to ensure that subdomain
127: %% doesn't affect anything)
128: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_2)),
129: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_3)),
130: ?assertEqual(true, maybe_add_domain_or_subdomain(?SUBDOMAIN_2)),
131: [begin %% repeat twice
132: %% register IQ handler for ?HOST_TYPE_2 domains
133: IQHandlerWithHostType = create_iq_handler_and_register(<<"IQH">>, ?HOST_TYPE_2,
134: ?NAMESPACE_1, ?COMPONENT),
135: ?assertEqualLists([{?COMPONENT, ?DOMAIN_2, ?NAMESPACE_1, IQHandlerWithHostType},
136: {?COMPONENT, ?DOMAIN_3, ?NAMESPACE_1, IQHandlerWithHostType}],
137: get_all_registered_iqs()),
138: ?assertEqual([], get_all_unregistered_iqs()),
139: meck:reset(gen_iq_component),
140: %% unregister IQ handler for ?HOST_TYPE_2 domains
141: ?assertEqual({ok, IQHandlerWithHostType},
142: unregister_iq_handler_for_domain(?HOST_TYPE_2, ?NAMESPACE_1,
143: ?COMPONENT)),
144: ?assertEqual([], get_all_registered_iqs()),
145: ?assertEqualLists([{?COMPONENT, ?DOMAIN_2, ?NAMESPACE_1},
146: {?COMPONENT, ?DOMAIN_3, ?NAMESPACE_1}],
147: get_all_unregistered_iqs()),
148: meck:reset(gen_iq_component)
149: end || _ <- lists:seq(1, 2)],
150: %% remove 2 domains and one subdomain for ?HOST_TYPE_2
151: maybe_remove_domain(domain_host_type(?DOMAIN_2), ?DOMAIN_2),
152: maybe_remove_domain(domain_host_type(?DOMAIN_3), ?DOMAIN_3),
153: maybe_remove_subdomain(subdomain_info(?SUBDOMAIN_2)),
154: ?assertEqual([], get_all_registered_iqs()),
155: ?assertEqual([], get_all_unregistered_iqs()).
156:
157: can_add_domain_for_a_registered_iq_handler(_Config) ->
158: %%-------------------------------------------------------------------------------
159: %% this test case consists of the following steps:
160: %% 1) register 2 IQ handlers for ?HOST_TYPE_1 domains
161: %% 2) add ?SUBDOMAIN_1 (?HOST_TYPE_1, just to ensure that subdomain adding
162: %% doesn't affect anything)
163: %% 3) add and then remove ?DOMAIN_1, check that it leads to the execution of
164: %% the proper gen_iq_component interfaces (run this step twice)
165: %% 4) unregister 2 IQ handlers ?HOST_TYPE_1 domains
166: %%-------------------------------------------------------------------------------
167:
168: %% register 2 IQ handlers
169: IQHandlerWithHostType1 = create_iq_handler_and_register(<<"IQH1">>, ?HOST_TYPE_1,
170: ?NAMESPACE_1, ?COMPONENT),
171: IQHandlerWithHostType2 = create_iq_handler_and_register(<<"IQH2">>, ?HOST_TYPE_1,
172: ?NAMESPACE_2, ?COMPONENT),
173: %% add ?SUBDOMAIN_1
174: ?assertEqual(true, maybe_add_domain_or_subdomain(?SUBDOMAIN_1)),
175: ?assertEqual([], get_all_registered_iqs()),
176: [begin %% repeat twice
177: %% add ?DOMAIN_1
178: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_1)),
179: ?assertEqualLists([{?COMPONENT, ?DOMAIN_1, ?NAMESPACE_1,
180: IQHandlerWithHostType1},
181: {?COMPONENT, ?DOMAIN_1, ?NAMESPACE_2,
182: IQHandlerWithHostType2}],
183: get_all_registered_iqs()),
184: ?assertEqual([], get_all_unregistered_iqs()),
185: meck:reset(gen_iq_component),
186: %% remove ?DOMAIN_1
187: maybe_remove_domain(?HOST_TYPE_1, ?DOMAIN_1),
188: mongoose_lazy_routing:sync(),
189: ?assertEqual([], get_all_registered_iqs()),
190: ?assertEqualLists([{?COMPONENT, ?DOMAIN_1, ?NAMESPACE_1},
191: {?COMPONENT, ?DOMAIN_1, ?NAMESPACE_2}],
192: get_all_unregistered_iqs()),
193: meck:reset(gen_iq_component)
194: end || _ <- lists:seq(1, 2)],
195: %% unregister 2 IQ handlers
196: ?assertEqual({ok, IQHandlerWithHostType1},
197: unregister_iq_handler_for_domain(?HOST_TYPE_1, ?NAMESPACE_1,
198: ?COMPONENT)),
199: ?assertEqual({ok, IQHandlerWithHostType2},
200: unregister_iq_handler_for_domain(?HOST_TYPE_1, ?NAMESPACE_2,
201: ?COMPONENT)),
202: ?assertEqual([], get_all_unregistered_iqs()),
203: ?assertEqual([], get_all_registered_iqs()).
204:
205: can_register_and_unregister_iq_handler_for_two_subdomains(_Config) ->
206: %% add 2 subdomains for ?HOST_TYPE_2 and one domain (just to ensure that domain
207: %% doesn't affect anything)
208: ?assertEqual(true, maybe_add_domain_or_subdomain(?SUBDOMAIN_2)),
209: ?assertEqual(true, maybe_add_domain_or_subdomain(?SUBDOMAIN_3)),
210: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_2)),
211: Pattern = subdomain_pattern(?SUBDOMAIN_2),
212: [begin %% repeat twice
213: %% register IQ handler for ?HOST_TYPE_2 subdomains
214: IQHandlerWithHostType = create_iq_handler_and_register(<<"IQH">>, ?HOST_TYPE_2,
215: Pattern, ?NAMESPACE_1,
216: ?COMPONENT),
217: ?assertEqualLists([{?COMPONENT, ?SUBDOMAIN_2, ?NAMESPACE_1,
218: IQHandlerWithHostType},
219: {?COMPONENT, ?SUBDOMAIN_3, ?NAMESPACE_1,
220: IQHandlerWithHostType}],
221: get_all_registered_iqs()),
222: ?assertEqual([], get_all_unregistered_iqs()),
223: meck:reset(gen_iq_component),
224: %% unregister IQ handler for ?HOST_TYPE_2 subdomains
225: ?assertEqual({ok, IQHandlerWithHostType},
226: unregister_iq_handler_for_subdomain(?HOST_TYPE_2, Pattern,
227: ?NAMESPACE_1, ?COMPONENT)),
228: ?assertEqual([], get_all_registered_iqs()),
229: ?assertEqualLists([{?COMPONENT, ?SUBDOMAIN_2, ?NAMESPACE_1},
230: {?COMPONENT, ?SUBDOMAIN_3, ?NAMESPACE_1}],
231: get_all_unregistered_iqs()),
232: meck:reset(gen_iq_component)
233: end || _ <- lists:seq(1, 2)],
234: %% remove 2 subdomains and one domain for ?HOST_TYPE_2
235: maybe_remove_subdomain(subdomain_info(?SUBDOMAIN_2)),
236: maybe_remove_subdomain(subdomain_info(?SUBDOMAIN_3)),
237: maybe_remove_domain(domain_host_type(?DOMAIN_2), ?DOMAIN_2),
238: ?assertEqual([], get_all_registered_iqs()),
239: ?assertEqual([], get_all_unregistered_iqs()).
240:
241: can_add_subdomain_for_a_registered_iq_handler(_Config) ->
242: %%-------------------------------------------------------------------------------
243: %% this test case consists of the following steps:
244: %% 1) register 2 IQ handlers for ?HOST_TYPE_1 subdomains
245: %% 2) add ?DOMAIN_1 (?HOST_TYPE_1, just to ensure that domain adding
246: %% doesn't affect anything)
247: %% 3) add and then remove ?SUBDOMAIN_1, check that it leads to the execution of
248: %% the proper gen_iq_component interfaces (run this step twice)
249: %% 4) unregister 2 IQ handlers ?HOST_TYPE_1 subdomains
250: %%-------------------------------------------------------------------------------
251:
252: %% register 2 IQ handlers
253: Pattern = subdomain_pattern(?SUBDOMAIN_1),
254: IQHandlerWithHostType1 = create_iq_handler_and_register(<<"IQH1">>, ?HOST_TYPE_1,
255: Pattern, ?NAMESPACE_1,
256: ?COMPONENT),
257: IQHandlerWithHostType2 = create_iq_handler_and_register(<<"IQH2">>, ?HOST_TYPE_1,
258: Pattern, ?NAMESPACE_2,
259: ?COMPONENT),
260: %% add ?SUBDOMAIN_1
261: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_1)),
262: ?assertEqual([], get_all_registered_iqs()),
263: [begin %% repeat twice
264: %% add ?SUBDOMAIN_1
265: ?assertEqual(true, maybe_add_domain_or_subdomain(?SUBDOMAIN_1)),
266: ?assertEqualLists([{?COMPONENT, ?SUBDOMAIN_1, ?NAMESPACE_1,
267: IQHandlerWithHostType1},
268: {?COMPONENT, ?SUBDOMAIN_1, ?NAMESPACE_2,
269: IQHandlerWithHostType2}],
270: get_all_registered_iqs()),
271: ?assertEqual([], get_all_unregistered_iqs()),
272: meck:reset(gen_iq_component),
273: %% remove ?SUBDOMAIN_1
274: maybe_remove_subdomain(subdomain_info(?SUBDOMAIN_1)),
275: mongoose_lazy_routing:sync(),
276: ?assertEqual([], get_all_registered_iqs()),
277: ?assertEqualLists([{?COMPONENT, ?SUBDOMAIN_1, ?NAMESPACE_1},
278: {?COMPONENT, ?SUBDOMAIN_1, ?NAMESPACE_2}],
279: get_all_unregistered_iqs()),
280: meck:reset(gen_iq_component)
281: end || _ <- lists:seq(1, 2)],
282: %% unregister 2 IQ handlers
283: ?assertEqual({ok, IQHandlerWithHostType1},
284: unregister_iq_handler_for_subdomain(?HOST_TYPE_1, Pattern,
285: ?NAMESPACE_1, ?COMPONENT)),
286: ?assertEqual({ok, IQHandlerWithHostType2},
287: unregister_iq_handler_for_subdomain(?HOST_TYPE_1, Pattern,
288: ?NAMESPACE_2, ?COMPONENT)),
289: ?assertEqual([], get_all_unregistered_iqs()),
290: ?assertEqual([], get_all_registered_iqs()).
291:
292: handles_double_iq_handler_registration_deregistration_for_domain(_Config) ->
293: %% add one domain and register IQ handler for it.
294: ?assertEqual(true, maybe_add_domain_or_subdomain(?DOMAIN_1)),
295: IQHandlerWithHostType = create_iq_handler_and_register(<<"IQH">>, ?HOST_TYPE_1,
296: ?NAMESPACE_1, ?COMPONENT),
297: ?assertEqual([{?COMPONENT, ?DOMAIN_1, ?NAMESPACE_1, IQHandlerWithHostType}],
298: get_all_registered_iqs()),
299: meck:reset(gen_iq_component),
300: %% try to register IQ handler for the same host type,
301: %% component and namespace one more time.
302: ?assertEqual({error, already_registered},
303: register_iq_handler_for_domain(?HOST_TYPE_1, ?NAMESPACE_1, ?COMPONENT,
304: IQHandlerWithHostType)),
305: ?assertEqual([], get_all_registered_iqs()),
306: ?assertEqual([], get_all_unregistered_iqs()),
307: %% unregister IQ handler.
308: ?assertEqual({ok, IQHandlerWithHostType},
309: unregister_iq_handler_for_domain(?HOST_TYPE_1, ?NAMESPACE_1,
310: ?COMPONENT)),
311: ?assertEqual([{?COMPONENT, ?DOMAIN_1, ?NAMESPACE_1}], get_all_unregistered_iqs()),
312: meck:reset(gen_iq_component),
313: %% try unregister IQ handler one more time.
314: ?assertEqual({error, not_found},
315: unregister_iq_handler_for_domain(?HOST_TYPE_1, ?NAMESPACE_1,
316: ?COMPONENT)),
317: ?assertEqual([], get_all_registered_iqs()),
318: ?assertEqual([], get_all_unregistered_iqs()).
319:
320: handles_double_iq_handler_registration_deregistration_for_subdomain(_Config) ->
321: %% add one subdomain and register IQ handler for it.
322: Pattern = subdomain_pattern(?SUBDOMAIN_1),
323: ?assertEqual(true, maybe_add_domain_or_subdomain(?SUBDOMAIN_1)),
324: IQHandlerWithHostType = create_iq_handler_and_register(<<"IQH">>, ?HOST_TYPE_1,
325: Pattern, ?NAMESPACE_1,
326: ?COMPONENT),
327: ?assertEqual([{?COMPONENT, ?SUBDOMAIN_1, ?NAMESPACE_1, IQHandlerWithHostType}],
328: get_all_registered_iqs()),
329: meck:reset(gen_iq_component),
330: %% try to register IQ handler for the same subdomain pattern,
331: %% component and namespace one more time.
332: ?assertEqual({error, already_registered},
333: register_iq_handler_for_subdomain(?HOST_TYPE_1, Pattern, ?NAMESPACE_1,
334: ?COMPONENT, IQHandlerWithHostType)),
335: ?assertEqual([], get_all_registered_iqs()),
336: ?assertEqual([], get_all_unregistered_iqs()),
337: %% unregister IQ handler.
338: ?assertEqual({ok, IQHandlerWithHostType},
339: unregister_iq_handler_for_subdomain(?HOST_TYPE_1, Pattern,
340: ?NAMESPACE_1, ?COMPONENT)),
341: ?assertEqual([{?COMPONENT, ?SUBDOMAIN_1, ?NAMESPACE_1}],
342: get_all_unregistered_iqs()),
343: meck:reset(gen_iq_component),
344: %% try unregister IQ handler one more time.
345: ?assertEqual({error, not_found},
346: unregister_iq_handler_for_subdomain(?HOST_TYPE_1, Pattern,
347: ?NAMESPACE_1, ?COMPONENT)),
348: ?assertEqual([], get_all_registered_iqs()),
349: ?assertEqual([], get_all_unregistered_iqs()).
350:
351: %%-------------------------------------------------------------------
352: %% internal functions
353: %%-------------------------------------------------------------------
354: setup_meck() ->
355: Modules = [ejabberd_local, mongoose_router, gen_iq_component,
356: mongoose_domain_core, mongoose_subdomain_core],
357: [meck:new(M, [no_link]) || M <- Modules],
358: meck:new(mongoose_lazy_routing, [no_link, passthrough]),
359: meck:expect(ejabberd_local, register_host, fun(_) -> ok end),
360: meck:expect(ejabberd_local, unregister_host, fun(_) -> ok end),
361: meck:expect(mongoose_router, unregister_route, fun(_) -> ok end),
362: meck:expect(mongoose_router, register_route, fun(_, _) -> ok end),
363: meck:expect(gen_iq_component, register_iq_handler, fun(_, _, _, _) -> ok end),
364: meck:expect(gen_iq_component, sync, fun(_) -> ok end),
365: meck:expect(gen_iq_component, unregister_iq_handler, fun(_, _, _) -> ok end),
366: meck:expect(mongoose_domain_core, get_host_type, fun get_domain_host_type/1),
367: meck:expect(mongoose_subdomain_core, get_host_type, fun get_subdomain_host_type/1),
368: meck:expect(mongoose_subdomain_core, get_subdomain_info, fun get_subdomain_info/1).
369:
370: predefined_domains() ->
371: #{?DOMAIN_1 => ?HOST_TYPE_1,
372: ?DOMAIN_2 => ?HOST_TYPE_2,
373: ?DOMAIN_3 => ?HOST_TYPE_2,
374: ?DOMAIN_X => ?HOST_TYPE_1}.
375:
376: -spec predefined_subdomains() ->
377: #{jid:lserver() => mongoose_subdomain_core:subdomain_info()}.
378: predefined_subdomains() ->
379: SubdomainPattern = mongoose_subdomain_utils:make_subdomain_pattern(<<"sub.@HOST@">>),
380: FQDNPattern = mongoose_subdomain_utils:make_subdomain_pattern(?DOMAIN_X),
381: #{?SUBDOMAIN_1 =>
382: #{host_type => ?HOST_TYPE_1, subdomain => ?SUBDOMAIN_1,
383: subdomain_pattern => SubdomainPattern, parent_domain => ?DOMAIN_1,
384: packet_handler => mongoose_packet_handler:new(packet_handler_1,
385: #{host_type => ?HOST_TYPE_1})},
386: ?SUBDOMAIN_2 =>
387: #{host_type => ?HOST_TYPE_2, subdomain => ?SUBDOMAIN_2,
388: subdomain_pattern => SubdomainPattern, parent_domain => ?DOMAIN_2,
389: packet_handler => mongoose_packet_handler:new(packet_handler_2,
390: #{host_type => ?HOST_TYPE_2})},
391: ?SUBDOMAIN_3 =>
392: #{host_type => ?HOST_TYPE_2, subdomain => ?SUBDOMAIN_3,
393: subdomain_pattern => SubdomainPattern, parent_domain => ?DOMAIN_3,
394: packet_handler => mongoose_packet_handler:new(packet_handler_3,
395: #{host_type => ?HOST_TYPE_2})},
396: ?DOMAIN_X =>
397: #{host_type => ?HOST_TYPE_1, subdomain => ?DOMAIN_X,
398: subdomain_pattern => FQDNPattern, parent_domain => no_parent_domain,
399: packet_handler => mongoose_packet_handler:new(packet_handler_x,
400: #{host_type => ?HOST_TYPE_1})}}.
401:
402: get_domain_host_type(Domain) ->
403: case maps:get(Domain, predefined_domains(), undefined) of
404: undefined -> {error, not_found};
405: HostType -> {ok, HostType}
406: end.
407:
408: domain_host_type(Domain) ->
409: element(2, get_domain_host_type(Domain)).
410:
411: get_subdomain_host_type(?MISSING_DOMAIN) ->
412: %% required for handles_domain_or_subdomain_removal_while_adding test case
413: {ok, ?HOST_TYPE_1};
414: get_subdomain_host_type(Subdomain) ->
415: case maps:get(Subdomain, predefined_subdomains(), undefined) of
416: undefined -> {error, not_found};
417: SubdomainInfo -> {ok, maps:get(host_type, SubdomainInfo)}
418: end.
419:
420: get_subdomain_info(Subdomain) ->
421: case maps:get(Subdomain, predefined_subdomains(), undefined) of
422: undefined -> {error, not_found};
423: SubdomainInfo -> {ok, SubdomainInfo}
424: end.
425:
426: subdomain_info(Subdomain) ->
427: element(2, get_subdomain_info(Subdomain)).
428:
429: packet_handler(Subdomain) ->
430: maps:get(packet_handler, maps:get(Subdomain, predefined_subdomains())).
431:
432: subdomain_pattern(Subdomain) ->
433: maps:get(subdomain_pattern, maps:get(Subdomain, predefined_subdomains())).
434:
435: iq_handler(Extra) ->
436: FN = fun(Acc, _From, _To, _IQ, _Extra) -> {Acc, ignore} end,
437: %% using no_queue execution type to ensure this function returns
438: %% one the same IQ handler if we call it with the same parameters.
439: mongoose_iq_handler:new(FN, Extra, no_queue).
440:
441: get_all_registered_domains() ->
442: History = meck:history(ejabberd_local),
443: [Domain || {_Pid, {_Mod, Func, [Domain] = _Args}, _Result} <- History,
444: Func =:= register_host].
445:
446: get_all_unregistered_domains() ->
447: History = meck:history(ejabberd_local),
448: [Domain || {_Pid, {_Mod, Func, [Domain] = _Args}, _Result} <- History,
449: Func =:= unregister_host].
450:
451: get_all_registered_subdomains() ->
452: History = meck:history(mongoose_router),
453: [{Subdomain, PacketHandler}
454: || {_Pid, {_Mod, Func, [Subdomain, PacketHandler] = _Args}, _Result} <- History,
455: Func =:= register_route].
456:
457: get_all_unregistered_subdomains() ->
458: History = meck:history(mongoose_router),
459: [Subdomain || {_Pid, {_Mod, Func, [Subdomain] = _Args}, _Result} <- History,
460: Func =:= unregister_route].
461:
462: create_iq_handler_and_register(Tag, HostType, Namespace, Component) ->
463: IQHandler = iq_handler(#{tag => Tag}),
464: Ret = register_iq_handler_for_domain(HostType, Namespace, Component, IQHandler),
465: ?assertEqual(ok, Ret),
466: mongoose_iq_handler:add_extra(IQHandler, #{host_type => HostType}).
467:
468: create_iq_handler_and_register(Tag, HostType, SubdomainPattern, Namespace, Component) ->
469: IQHandler = iq_handler(#{tag => Tag}),
470: Ret = register_iq_handler_for_subdomain(HostType, SubdomainPattern, Namespace,
471: Component, IQHandler),
472: ?assertEqual(ok, Ret),
473: mongoose_iq_handler:add_extra(IQHandler, #{host_type => HostType}).
474:
475: get_all_registered_iqs() ->
476: History = meck:history(gen_iq_component),
477: [list_to_tuple(Args)
478: || {_Pid, {_Mod, register_iq_handler = _Func, Args}, _Result} <- History].
479:
480: get_all_unregistered_iqs() ->
481: History = meck:history(gen_iq_component),
482: [list_to_tuple(Args)
483: || {_Pid, {_Mod, unregister_iq_handler = _Func, Args}, _Result} <- History].