Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

More parallel tests #1038

Merged
merged 15 commits into from
Oct 26, 2016
+480 −378
Merged

More parallel tests #1038

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
15 commits
Select commit Hold shift + click to select a range
7e7ccb2
parallelize mod_ping_SUITE
michalwski Oct 17, 2016
677ac43
replace macros with functions for pubsbu nodes in pubsub_SUITE
michalwski Oct 17, 2016
17eb971
replace macros with functions for pubsub leafs in pubsub_SUITE
michalwski Oct 17, 2016
b66a22d
randomize pubsub node and leaf names
michalwski Oct 18, 2016
6825ea8
use randomized names for second pubsub nodes and leafs
michalwski Oct 18, 2016
72d78fb
replace ?DOMAIN macro with function reading actaull domain from config
michalwski Oct 18, 2016
e0d7a16
move pubsub modules initialisation to init_per_suite
michalwski Oct 18, 2016
def9e1d
fix pubsubs discover nodes check
michalwski Oct 18, 2016
9198e1c
parallelise pubsub_SUITE
michalwski Oct 18, 2016
c367e2c
use xmpp registration only when needed
michalwski Oct 18, 2016
ae5c5f2
parallelise all login groups
michalwski Oct 18, 2016
11079c4
add missing spaces after , found by Elvis
michalwski Oct 19, 2016
f3f25bb
increase wait time between registration
michalwski Oct 19, 2016
d5060f4
configure s2s connection timeout to 1s for amp_SUITE
michalwski Oct 25, 2016
f878497
make basic group in amp_SUITE parallel
michalwski Oct 25, 2016
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
16 changes: 12 additions & 4 deletions test/ejabberd_tests/tests/amp_SUITE.erl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -21,7 +21,7 @@ enabled_group_names() ->
end.

groups() ->
[{basic, [], [{group, G} || G <- subgroup_names()] ++ basic_test_cases()},
[{basic, [parallel], [{group, G} || G <- subgroup_names()] ++ basic_test_cases()},
{mam, [], [{group, mam_success},
{group, mam_failure}]},
{mam_success, [], [{group, G} || G <- subgroup_names()]},
Expand Down Expand Up @@ -94,8 +94,16 @@ drop_deliver_test_cases() ->
drop_deliver_to_offline_user_test,
drop_deliver_to_stranger_test].

init_per_suite(C) -> escalus:init_per_suite(C).
end_per_suite(C) -> ok = escalus_fresh:clean(), escalus:end_per_suite(C).
init_per_suite(C) ->
escalus_ejabberd:rpc(ejabberd_config, add_local_option,
[outgoing_s2s_options, {[ipv4, ipv6], 1000}]),
escalus:init_per_suite(C).
end_per_suite(C) ->
escalus_ejabberd:rpc(ejabberd_config, del_local_option,
[outgoing_s2s_options]),

escalus_fresh:clean(),
escalus:end_per_suite(C).

init_per_group(GroupName, Config) ->
ConfigWithModules = dynamic_modules:save_modules(domain(), Config),
Expand Down Expand Up @@ -712,7 +720,7 @@ client_receives_amp_error(Client, IntendedRecipient, Rule, AmpErrorKind) ->
Received, Rule, AmpErrorKind).

client_receives_generic_error(Client, Code, Type) ->
Received = escalus_client:wait_for_stanza(Client),
Received = escalus_client:wait_for_stanza(Client, 5000),
escalus:assert(fun contains_error/3, [Code, Type], Received).

client_receives_nothing(Client) ->
Expand Down
75 changes: 45 additions & 30 deletions test/ejabberd_tests/tests/login_SUITE.erl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -56,10 +56,10 @@ groups() ->
registration_failure_timeout]},
{change_account_details, [no_sequence], [change_password,
change_password_to_null]},
{login, [sequence], all_tests()},
{login_scram, [sequence], scram_tests()},
{login_scram_store_plain, [sequence], scram_tests()},
{legacy_auth, [sequence], [legacy_successful_plain,
{login, [parallel], all_tests()},
{login_scram, [parallel], scram_tests()},
{login_scram_store_plain, [parallel], scram_tests()},
{legacy_auth, [parallel], [legacy_successful_plain,
legacy_unsuccessful_plain,
legacy_successful_digest,
legacy_blocked_user]},
Expand All @@ -86,17 +86,18 @@ suite() ->
%%--------------------------------------------------------------------

init_per_suite(Config) ->
[{escalus_user_db, xmpp} | escalus:init_per_suite(Config)].
escalus:init_per_suite(Config).

end_per_suite(Config) ->
escalus_fresh:clean(),
escalus:end_per_suite(Config).

init_per_group(register, Config) ->
skip_if_mod_register_not_enabled(Config);
[{escalus_user_db, xmpp} | skip_if_mod_register_not_enabled(Config)];
init_per_group(bad_registration, Config) ->
Config;
[{escalus_user_db, xmpp} | Config];
init_per_group(bad_cancelation, Config) ->
skip_if_mod_register_not_enabled(Config);
[{escalus_user_db, xmpp} | skip_if_mod_register_not_enabled(Config)];
init_per_group(registration_timeout, Config) ->
case escalus_users:is_mod_register_enabled(Config) of
true ->
Expand Down Expand Up @@ -177,19 +178,9 @@ init_per_testcase(message_zlib_limit, Config) ->
false ->
{skip, port_not_configured_on_server}
end;
init_per_testcase(Name, Config)
when Name == blocked_user; Name == legacy_blocked_user ->
Domain = ct:get_config(ejabberd_domain),
escalus_ejabberd:rpc(acl, add, [Domain, blocked, {user, <<"alice">>}]),
escalus:init_per_testcase(Name, Config);
init_per_testcase(CaseName, Config) ->
escalus:init_per_testcase(CaseName, Config).

end_per_testcase(Name, Config)
when Name == blocked_user; Name == legacy_blocked_user ->
Domain = ct:get_config(ejabberd_domain),
escalus_ejabberd:rpc(acl, delete, [Domain, blocked, {user, <<"alice">>}]),
Config;
end_per_testcase(change_password, Config) ->
[{alice, Details}] = escalus_users:get_users([alice]),
Alice = {alice, lists:keyreplace(password, 1, Details, {password, strong_pwd()})},
Expand All @@ -214,7 +205,6 @@ end_per_testcase(registration_failure_timeout, Config) ->
end_per_testcase(CaseName, Config) ->
escalus:end_per_testcase(CaseName, Config).


%%--------------------------------------------------------------------
%% Message tests
%%--------------------------------------------------------------------
Expand Down Expand Up @@ -338,7 +328,7 @@ registration_timeout(Config) ->
escalus_users:verify_creation(escalus_users:create_user(Config, Bob)).

registration_failure_timeout(Config) ->
timer:sleep(timer:seconds(?REGISTRATION_TIMEOUT)),
timer:sleep(timer:seconds(?REGISTRATION_TIMEOUT + 1)),
[Alice] = escalus_users:get_users([alice]),

%% Registration of the first user should fail because of access denial
Expand Down Expand Up @@ -399,7 +389,7 @@ change_password_to_null(Config) ->
end).

log_one(Config) ->
escalus:story(Config, [{alice, 1}], fun(Alice) ->
escalus:fresh_story(Config, [{alice, 1}], fun(Alice) ->

escalus_client:send(Alice, escalus_stanza:chat_to(Alice, <<"Hi!">>)),
escalus:assert(is_chat_message, [<<"Hi!">>], escalus_client:wait_for_stanza(Alice))
Expand Down Expand Up @@ -431,12 +421,15 @@ log_non_existent(Config) ->

blocked_user(_Config) ->
[{_, Spec}] = escalus_users:get_users([alice]),
set_acl_for_blocking(Spec),
try
{ok, _Alice, _Spec2, _Features} = escalus_connection:start(Spec),
ct:fail("Alice authenticated but shouldn't")
catch
error:{assertion_failed, assert, is_iq_result, Stanza, _Bin} ->
<<"cancel">> = exml_query:path(Stanza, [{element, <<"error">>}, {attr, <<"type">>}])
after
unset_acl_for_blocking(Spec)
end,
ok.

Expand Down Expand Up @@ -471,23 +464,26 @@ legacy_successful_digest(Config) ->

legacy_successful_plain(Config) ->
legacy_auth(Config, legacy_auth_plain).
legacy_unsuccessful_plain(Config) ->

legacy_unsuccessful_plain(ConfigIn) ->
Config = escalus_fresh:create_users(ConfigIn, [{alice, 1}]),
Spec = escalus_users:get_userspec(Config, alice),
NewSpec = lists:keyreplace(password, 1, Spec, {password, <<"wrong_pass">>}),
Users = ?config(escalus_users, Config),
NewUsers = lists:keyreplace(alice, 1, Users, {alice, NewSpec}),
NewConfig = lists:keyreplace(escalus_users, 1, Config, {escalus_users, NewUsers}),
try
legacy_auth(NewConfig, legacy_auth_plain),
do_legacy_auth(NewSpec, legacy_auth_plain),
ct:fail("Authenticated but shouldn't")
catch
error:{assertion_failed,assert,is_iq_result,_,_,_} ->
error:{assertion_failed, assert, is_iq_result, _, _, _} ->
ok
end.

legacy_auth(Config, Function) ->
legacy_auth(ConfigIn, Function) ->
%% given
Config = escalus_fresh:create_users(ConfigIn, [{alice, 1}]),
Spec = escalus_users:get_userspec(Config, alice),
do_legacy_auth(Spec, Function).

do_legacy_auth(Spec, Function) ->
Steps = [
%% when
{legacy_stream_helper, start_stream_pre_xmpp_1_0},
Expand All @@ -498,15 +494,20 @@ legacy_auth(Config, Function) ->
escalus_connection:stop(Conn).


legacy_blocked_user(Config) ->
legacy_blocked_user(ConfigIn) ->
Config = escalus_fresh:create_users(ConfigIn, [{alice, 1}]),
Spec = escalus_users:get_userspec(Config, alice),
set_acl_for_blocking(Spec),
try
legacy_auth(Config, legacy_auth_plain),
do_legacy_auth(Spec, legacy_auth_plain),
ct:fail("alice authenticated but shouldn't")
catch
error:{assertion_failed, assert, is_iq_result, _, Stanza, _Bin} ->
<<"cancel">> = exml_query:path(Stanza,
[{element, <<"error">>},
{attr, <<"type">>}])
after
unset_acl_for_blocking(Spec)
end.

%%--------------------------------------------------------------------
Expand Down Expand Up @@ -632,3 +633,17 @@ user_exists(Name, Config) ->

string(<<_/binary>> = Subject) ->
erlang:binary_to_list(Subject).

set_acl_for_blocking(Spec) ->
modify_acl_for_blocking(add, Spec).

unset_acl_for_blocking(Spec) ->
modify_acl_for_blocking(delete, Spec).

modify_acl_for_blocking(Method, Spec) ->
ct:print("Spec: ~p", [Spec]),
Domain = ct:get_config({hosts, mim, domain}),
User = proplists:get_value(username, Spec),
Lower = escalus_utils:jid_to_lower(User),
escalus_ejabberd:rpc(acl, Method, [Domain, blocked, {user, Lower}]).

54 changes: 33 additions & 21 deletions test/ejabberd_tests/tests/mod_ping_SUITE.erl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -29,8 +29,8 @@ all() ->

groups() ->
[{client_ping, [], [ping]},
{server_ping, [], all_tests()},
{server_ping_kill, [], all_tests()}
{server_ping, [parallel], all_tests()},
{server_ping_kill, [parallel], all_tests()}
].

all_tests() ->
Expand All @@ -42,31 +42,38 @@ all_tests() ->
suite() ->
escalus:suite().

ping_interval() ->
6.

ping_req_timeout() ->
3.

init_per_suite(Config) ->
escalus:init_per_suite(Config).

end_per_suite(Config) ->
escalus_fresh:clean(),
escalus:end_per_suite(Config).

init_per_group(client_ping, Config) ->
start_mod_ping([]),
escalus:create_users(Config, escalus:get_users([alice]));
Config;
init_per_group(server_ping, Config) ->
start_mod_ping([{send_pings, true},
{ping_interval, 8},
{ping_req_timeout, 4}]),
escalus:create_users(Config, escalus:get_users([alice]));
{ping_interval, ping_interval()},
{ping_req_timeout, ping_req_timeout()}]),
Config;
init_per_group(server_ping_kill, Config) ->
start_mod_ping([{send_pings, true},
{ping_interval, 8},
{ping_req_timeout, 4},
{ping_interval, ping_interval()},
{ping_req_timeout, ping_req_timeout()},
{timeout_action, kill}]),
[{timeout_action, kill} | escalus:create_users(Config, escalus:get_users([alice]))].
[{timeout_action, kill} | Config].

end_per_group(_GroupName, Config) ->
Domain = ct:get_config(ejabberd_domain),
dynamic_modules:stop(Domain, mod_ping),
escalus:delete_users(Config, escalus:get_users([alice])).
Config.

init_per_testcase(CaseName, Config) ->
escalus:init_per_testcase(CaseName, Config).
Expand All @@ -82,7 +89,7 @@ start_mod_ping(Opts) ->
%% Ping tests
%%--------------------------------------------------------------------
ping(Config) ->
escalus:story(Config, [{alice, 1}],
escalus:fresh_story(Config, [{alice, 1}],
fun(Alice) ->
Domain = ct:get_config(ejabberd_domain),
PingReq = escalus_stanza:ping_request(Domain),
Expand All @@ -93,30 +100,31 @@ ping(Config) ->
end).

active(Config) ->
escalus:story(Config, [{alice, 1}],
escalus:fresh_story(Config, [{alice, 1}],
fun(Alice) ->
Domain = ct:get_config(ejabberd_domain),
ct:sleep(timer:seconds(6)), % wait 6s (ping_interval is 8)
wait_ping_interval(0.75),
escalus_client:send(Alice, escalus_stanza:ping_request(Domain)),
escalus:assert(is_iq_result, escalus_client:wait_for_stanza(Alice)),
ct:sleep(timer:seconds(4)), % wait another 4s and check if connection we got ping req

% wait more time and check if connection got ping req
wait_ping_interval(0.5),
% it shouldn't as the ping was sent
false = escalus_client:has_stanzas(Alice)
end).

active_keep_alive(Config) ->
escalus:story(Config, [{alice, 1}],
escalus:fresh_story(Config, [{alice, 1}],
fun(Alice) ->
ct:sleep(timer:seconds(6)), % wait 6s (ping_interval is 8)
wait_ping_interval(0.75),
Socket = Alice#client.socket,
gen_tcp:send(Socket, <<"\n">>),
ct:sleep(timer:seconds(4)), % wait another 4s and check if connection we got ping req
wait_ping_interval(0.5),

false = escalus_client:has_stanzas(Alice)
end).

server_ping_pong(Config) ->
escalus:story(Config, [{alice, 1}],
escalus:fresh_story(Config, [{alice, 1}],
fun(Alice) ->
PingReq = wait_for_ping_req(Alice),
Pong = escalus_stanza:iq_result(PingReq),
Expand All @@ -127,15 +135,19 @@ server_ping_pang(ConfigIn) ->
Domain = ct:get_config(ejabberd_domain),
Metrics = [{[Domain, user_ping_timeout], 1}],
Config = [{mongoose_metrics, Metrics} | ConfigIn],
escalus:story(Config, [{alice, 1}],
escalus:fresh_story(Config, [{alice, 1}],
fun(Alice) ->
wait_for_ping_req(Alice),
%% do not resp to ping req
ct:sleep(timer:seconds(5)), %% server waits 4s for the reply
ct:sleep(timer:seconds(ping_req_timeout() + 1)),
TimeoutAction = ?config(timeout_action, Config),
check_connection(TimeoutAction, Alice)
end).

wait_ping_interval(Ration) ->
WaitTime = timer:seconds(ping_interval()) * Ration,
ct:sleep(WaitTime).

check_connection(kill, Client) ->
false = escalus_connection:is_connected(Client);
check_connection(_, Client) ->
Expand Down
Loading