702 lines
25 KiB
Elixir
702 lines
25 KiB
Elixir
# ----------------------------------------------------------------------
|
|
#
|
|
# ejabberd, Copyright (C) 2002-2015 ProcessOne
|
|
#
|
|
# This program is free software; you can redistribute it and/or
|
|
# modify it under the terms of the GNU General Public License as
|
|
# published by the Free Software Foundation; either version 2 of the
|
|
# License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
# General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License along
|
|
# with this program; if not, write to the Free Software Foundation, Inc.,
|
|
# 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
#
|
|
# ----------------------------------------------------------------------
|
|
|
|
defmodule EjabberdModAdminExtraTest do
|
|
use ExUnit.Case, async: false
|
|
|
|
require EjabberdAuthMock
|
|
|
|
@author "jsautret@process-one.net"
|
|
|
|
@user "user"
|
|
@domain "domain"
|
|
@password "password"
|
|
@resource "resource"
|
|
|
|
require Record
|
|
Record.defrecord :jid, Record.extract(:jid, from_lib: "ejabberd/include/jlib.hrl")
|
|
|
|
setup_all do
|
|
try do
|
|
:jid.start
|
|
:stringprep.start
|
|
:mnesia.start
|
|
:p1_sha.load_nif
|
|
rescue
|
|
_ -> :ok
|
|
end
|
|
:ejabberd_commands.init
|
|
:mod_admin_extra.start(@domain, [])
|
|
:sel_application.start_app(:moka)
|
|
{:ok, _pid} = :ejabberd_hooks.start_link
|
|
:ok
|
|
end
|
|
|
|
setup do
|
|
:meck.unload
|
|
EjabberdAuthMock.init
|
|
EjabberdSmMock.init
|
|
ModRosterMock.init(@domain, :mod_admin_extra)
|
|
:ok
|
|
end
|
|
|
|
###################### Accounts
|
|
test "check_account works" do
|
|
EjabberdAuthMock.create_user @user, @domain, @password
|
|
|
|
assert :ejabberd_commands.execute_command(:check_account, [@user, @domain])
|
|
refute :ejabberd_commands.execute_command(:check_account, [@user, "bad_domain"])
|
|
refute :ejabberd_commands.execute_command(:check_account, ["bad_user", @domain])
|
|
|
|
assert :meck.validate :ejabberd_auth
|
|
end
|
|
|
|
test "check_password works" do
|
|
|
|
EjabberdAuthMock.create_user @user, @domain, @password
|
|
|
|
assert :ejabberd_commands.execute_command(:check_password,
|
|
[@user, <<"">>, @domain, @password])
|
|
refute :ejabberd_commands.execute_command(:check_password,
|
|
[@user, <<"">>, @domain, "bad_password"])
|
|
refute :ejabberd_commands.execute_command(:check_password,
|
|
[@user, <<"">>, "bad_domain", @password])
|
|
refute :ejabberd_commands.execute_command(:check_password,
|
|
["bad_user", <<"">>, @domain, @password])
|
|
|
|
assert :meck.validate :ejabberd_auth
|
|
|
|
end
|
|
|
|
test "check_password_hash works" do
|
|
|
|
EjabberdAuthMock.create_user @user, @domain, @password
|
|
hash = "5F4DCC3B5AA765D61D8327DEB882CF99" # echo -n password|md5
|
|
|
|
assert :ejabberd_commands.execute_command(:check_password_hash,
|
|
[@user, @domain, hash, "md5"])
|
|
refute :ejabberd_commands.execute_command(:check_password_hash,
|
|
[@user, @domain, "bad_hash", "md5"])
|
|
refute :ejabberd_commands.execute_command(:check_password_hash,
|
|
[@user, "bad_domain", hash, "md5"])
|
|
refute :ejabberd_commands.execute_command(:check_password_hash,
|
|
["bad_user", @domain, hash, "md5"])
|
|
|
|
hash = "5BAA61E4C9B93F3F0682250B6CF8331B7EE68FD8" # echo -n password|shasum
|
|
assert :ejabberd_commands.execute_command(:check_password_hash,
|
|
[@user, @domain, hash, "sha"])
|
|
|
|
assert :unkown_hash_method ==
|
|
catch_throw :ejabberd_commands.execute_command(:check_password_hash,
|
|
[@user, @domain, hash, "bad_method"])
|
|
|
|
assert :meck.validate :ejabberd_auth
|
|
|
|
end
|
|
|
|
test "change_password works" do
|
|
EjabberdAuthMock.create_user @user, @domain, @password
|
|
|
|
assert :ejabberd_commands.execute_command(:change_password,
|
|
[@user, @domain, "new_password"])
|
|
refute :ejabberd_commands.execute_command(:check_password,
|
|
[@user, <<"">>, @domain, @password])
|
|
assert :ejabberd_commands.execute_command(:check_password,
|
|
[@user, <<"">>, @domain, "new_password"])
|
|
assert {:not_found, 'unknown_user'} ==
|
|
catch_throw :ejabberd_commands.execute_command(:change_password,
|
|
["bad_user", @domain,
|
|
@password])
|
|
assert :meck.validate :ejabberd_auth
|
|
end
|
|
|
|
test "check_users_registration works" do
|
|
EjabberdAuthMock.create_user @user<>"1", @domain, @password
|
|
EjabberdAuthMock.create_user @user<>"2", @domain, @password
|
|
EjabberdAuthMock.create_user @user<>"3", @domain, @password
|
|
|
|
assert [{@user<>"0", @domain, 0},
|
|
{@user<>"1", @domain, 1},
|
|
{@user<>"2", @domain, 1},
|
|
{@user<>"3", @domain, 1}] ==
|
|
:ejabberd_commands.execute_command(:check_users_registration,
|
|
[[{@user<>"0", @domain},
|
|
{@user<>"1", @domain},
|
|
{@user<>"2", @domain},
|
|
{@user<>"3", @domain}]])
|
|
|
|
assert :meck.validate :ejabberd_auth
|
|
|
|
end
|
|
|
|
###################### Sessions
|
|
|
|
test "num_resources works" do
|
|
assert 0 == :ejabberd_commands.execute_command(:num_resources,
|
|
[@user, @domain])
|
|
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource
|
|
assert 1 == :ejabberd_commands.execute_command(:num_resources,
|
|
[@user, @domain])
|
|
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource<>"2"
|
|
assert 2 == :ejabberd_commands.execute_command(:num_resources,
|
|
[@user, @domain])
|
|
|
|
EjabberdSmMock.connect_resource @user<>"1", @domain, @resource
|
|
assert 2 == :ejabberd_commands.execute_command(:num_resources,
|
|
[@user, @domain])
|
|
|
|
EjabberdSmMock.disconnect_resource @user, @domain, @resource
|
|
assert 1 == :ejabberd_commands.execute_command(:num_resources,
|
|
[@user, @domain])
|
|
|
|
assert :meck.validate :ejabberd_sm
|
|
end
|
|
|
|
test "resource_num works" do
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource<>"3"
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource<>"2"
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource<>"1"
|
|
|
|
assert :bad_argument ==
|
|
elem(catch_throw(:ejabberd_commands.execute_command(:resource_num,
|
|
[@user, @domain, 0])), 0)
|
|
assert @resource<>"1" ==
|
|
:ejabberd_commands.execute_command(:resource_num, [@user, @domain, 1])
|
|
assert @resource<>"3" ==
|
|
:ejabberd_commands.execute_command(:resource_num, [@user, @domain, 3])
|
|
assert :bad_argument ==
|
|
elem(catch_throw(:ejabberd_commands.execute_command(:resource_num,
|
|
[@user, @domain, 4])), 0)
|
|
assert :meck.validate :ejabberd_sm
|
|
end
|
|
|
|
test "kick_session works" do
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource<>"1"
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource<>"2"
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource<>"3"
|
|
|
|
assert 3 == length EjabberdSmMock.get_sessions @user, @domain
|
|
assert 1 == length EjabberdSmMock.get_session @user, @domain, @resource<>"2"
|
|
|
|
assert :ok ==
|
|
:ejabberd_commands.execute_command(:kick_session,
|
|
[@user, @domain,
|
|
@resource<>"2", "kick"])
|
|
|
|
assert 2 == length EjabberdSmMock.get_sessions @user, @domain
|
|
assert 0 == length EjabberdSmMock.get_session @user, @domain, @resource<>"2"
|
|
|
|
assert :meck.validate :ejabberd_sm
|
|
end
|
|
|
|
###################### Last
|
|
|
|
test "get_last works" do
|
|
|
|
assert 'Never' ==
|
|
:ejabberd_commands.execute_command(:get_last, [@user, @domain])
|
|
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource<>"1"
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource<>"2"
|
|
|
|
assert 'Online' ==
|
|
:ejabberd_commands.execute_command(:get_last, [@user, @domain])
|
|
|
|
EjabberdSmMock.disconnect_resource @user, @domain, @resource<>"1"
|
|
|
|
assert 'Online' ==
|
|
:ejabberd_commands.execute_command(:get_last, [@user, @domain])
|
|
|
|
now = {megasecs, secs, _microsecs} = :os.timestamp
|
|
timestamp = megasecs * 1000000 + secs
|
|
EjabberdSmMock.disconnect_resource(@user, @domain, @resource<>"2",
|
|
timestamp)
|
|
{{year, month, day}, {hour, minute, second}} = :calendar.now_to_local_time now
|
|
result = List.flatten(:io_lib.format(
|
|
"~w-~.2.0w-~.2.0w ~.2.0w:~.2.0w:~.2.0w ",
|
|
[year, month, day, hour, minute, second]))
|
|
assert result ==
|
|
:ejabberd_commands.execute_command(:get_last, [@user, @domain])
|
|
|
|
assert :meck.validate :mod_last
|
|
end
|
|
|
|
###################### Roster
|
|
|
|
test "add_rosteritem and delete_rosteritem work" do
|
|
# Connect user
|
|
# Add user1 & user2 to user's roster
|
|
# Remove user1 & user2 from user's roster
|
|
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource
|
|
|
|
assert [] == ModRosterMock.get_roster(@user, @domain)
|
|
|
|
assert :ok ==
|
|
:ejabberd_commands.execute_command(:add_rosteritem, [@user, @domain,
|
|
@user<>"1", @domain,
|
|
"nick1",
|
|
"group1",
|
|
"both"])
|
|
# Check that user1 is the only item of the user's roster
|
|
result = ModRosterMock.get_roster(@user, @domain)
|
|
assert 1 == length result
|
|
[{{@user, @domain, jid}, opts}] = result
|
|
assert @user<>"1@"<>@domain == jid
|
|
assert "nick1" == opts.nick
|
|
assert ["group1"] == opts.groups
|
|
assert :both == opts.subs
|
|
|
|
# Check that the item roster user1 was pushed with subscription
|
|
# 'both' to user online ressource
|
|
jid = :jlib.make_jid(@user, @domain, @resource)
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"1", @domain, ""}, :both}}])
|
|
|
|
assert :ok ==
|
|
:ejabberd_commands.execute_command(:add_rosteritem, [@user, @domain,
|
|
@user<>"2", @domain,
|
|
"nick2",
|
|
"group2",
|
|
"both"])
|
|
result = ModRosterMock.get_roster(@user, @domain)
|
|
assert 2 == length result
|
|
|
|
|
|
# Check that the item roster user2 was pushed with subscription
|
|
# 'both' to user online ressource
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"2", @domain, ""}, :both}}])
|
|
|
|
|
|
:ejabberd_commands.execute_command(:delete_rosteritem, [@user, @domain,
|
|
@user<>"1", @domain])
|
|
result = ModRosterMock.get_roster(@user, @domain)
|
|
assert 1 == length result
|
|
[{{@user, @domain, jid}, opts}] = result
|
|
assert @user<>"2@"<>@domain == jid
|
|
assert "nick2" == opts.nick
|
|
assert ["group2"] == opts.groups
|
|
assert :both == opts.subs
|
|
|
|
# Check that the item roster user1 was pushed with subscription
|
|
# 'none' to user online ressource
|
|
jid = :jlib.make_jid(@user, @domain, @resource)
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"1", @domain, ""}, :none}}])
|
|
|
|
:ejabberd_commands.execute_command(:delete_rosteritem, [@user, @domain,
|
|
@user<>"2", @domain])
|
|
|
|
# Check that the item roster user2 was pushed with subscription
|
|
# 'none' to user online ressource
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"2", @domain, ""}, :none}}])
|
|
|
|
# Check that nothing else was pushed to user resource
|
|
jid = jid(user: @user, server: @domain, resource: :_,
|
|
luser: @user, lserver: @domain, lresource: :_)
|
|
assert 4 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, :_, :_}}])
|
|
|
|
assert [] == ModRosterMock.get_roster(@user, @domain)
|
|
assert :meck.validate :ejabberd_sm
|
|
|
|
end
|
|
|
|
test "get_roster works" do
|
|
assert [] == ModRosterMock.get_roster(@user, @domain)
|
|
assert [] == :ejabberd_commands.execute_command(:get_roster, [@user, @domain],
|
|
:admin)
|
|
|
|
assert :ok ==
|
|
:ejabberd_commands.execute_command(:add_rosteritem, [@user, @domain,
|
|
@user<>"1", @domain,
|
|
"nick1",
|
|
"group1",
|
|
"both"])
|
|
assert [{@user<>"1@"<>@domain, "", 'both', 'none', "group1"}] ==
|
|
:ejabberd_commands.execute_command(:get_roster, [@user, @domain], :admin)
|
|
assert :ok ==
|
|
:ejabberd_commands.execute_command(:add_rosteritem, [@user, @domain,
|
|
@user<>"2", @domain,
|
|
"nick2",
|
|
"group2",
|
|
"none"])
|
|
result = :ejabberd_commands.execute_command(:get_roster, [@user, @domain], :admin)
|
|
assert 2 == length result
|
|
assert Enum.member?(result, {@user<>"1@"<>@domain, "", 'both', 'none', "group1"})
|
|
assert Enum.member?(result, {@user<>"2@"<>@domain, "", 'none', 'none', "group2"})
|
|
|
|
end
|
|
|
|
|
|
test "link_contacts & unlink_contacts work" do
|
|
# Create user1 and keep it offline
|
|
EjabberdAuthMock.create_user @user<>"1", @domain, @password
|
|
|
|
# fail if one of the users doesn't exist locally
|
|
assert 404 ==
|
|
:ejabberd_commands.execute_command(:link_contacts, [@user<>"1@"<>@domain,
|
|
"nick1",
|
|
"group1",
|
|
@user<>"2@"<>@domain,
|
|
"nick2",
|
|
"group2"])
|
|
|
|
# Create user2 and connect 2 resources
|
|
EjabberdAuthMock.create_user @user<>"2", @domain, @password
|
|
|
|
EjabberdSmMock.connect_resource @user<>"2", @domain, @resource<>"1"
|
|
EjabberdSmMock.connect_resource @user<>"2", @domain, @resource<>"2"
|
|
|
|
# Link both user1 & user2 (returns 0 if OK)
|
|
assert 0 ==
|
|
:ejabberd_commands.execute_command(:link_contacts, [@user<>"1@"<>@domain,
|
|
"nick1",
|
|
"group2",
|
|
@user<>"2@"<>@domain,
|
|
"nick2",
|
|
"group1"])
|
|
assert [{@user<>"2@"<>@domain, "", 'both', 'none', "group2"}] ==
|
|
:ejabberd_commands.execute_command(:get_roster, [@user<>"1", @domain], :admin)
|
|
|
|
assert [{@user<>"1@"<>@domain, "", 'both', 'none', "group1"}] ==
|
|
:ejabberd_commands.execute_command(:get_roster, [@user<>"2", @domain], :admin)
|
|
|
|
# Check that the item roster user1 was pushed with subscription
|
|
# 'both' to the 2 user2 online ressources
|
|
jid = :jlib.make_jid(@user<>"2", @domain, @resource<>"1")
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"1", @domain, ""}, :both}}])
|
|
jid = :jlib.make_jid(@user<>"2", @domain, @resource<>"2")
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"1", @domain, ""}, :both}}])
|
|
|
|
|
|
# Ulink both user1 & user2 (returns 0 if OK)
|
|
assert 0 ==
|
|
:ejabberd_commands.execute_command(:unlink_contacts, [@user<>"1@"<>@domain,
|
|
@user<>"2@"<>@domain])
|
|
assert [] ==
|
|
:ejabberd_commands.execute_command(:get_roster, [@user<>"1", @domain], :admin)
|
|
|
|
assert [] ==
|
|
:ejabberd_commands.execute_command(:get_roster, [@user<>"2", @domain], :admin)
|
|
|
|
# Check that the item roster user1 was pushed with subscription
|
|
# 'none' to the 2 user2 online ressources
|
|
jid = :jlib.make_jid(@user<>"2", @domain, @resource<>"1")
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"1", @domain, ""}, :none}}])
|
|
jid = :jlib.make_jid(@user<>"2", @domain, @resource<>"2")
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"1", @domain, ""}, :none}}])
|
|
|
|
# Check that nothing else was pushed to user2 resources
|
|
jid = jid(user: @user<>"2", server: @domain, resource: :_,
|
|
luser: @user<>"2", lserver: @domain, lresource: :_)
|
|
assert 4 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, :_, :_}}])
|
|
|
|
# Check nothing was pushed to user1
|
|
jid = jid(user: @user<>"1", server: @domain, resource: :_,
|
|
luser: @user<>"1", lserver: @domain, lresource: :_)
|
|
refute :meck.called(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, :_, :_}}])
|
|
|
|
assert :meck.validate :ejabberd_sm
|
|
assert :meck.validate :ejabberd_auth
|
|
|
|
end
|
|
|
|
|
|
|
|
|
|
test "add_contacts and delete_contacts work" do
|
|
# Create user, user1 & user2
|
|
# Connect user & user1
|
|
# Add user0, user1 & user2 to user's roster
|
|
# Remove user0, user1 & user2 from user's roster
|
|
|
|
# user doesn't exists yet, command must fail
|
|
assert 404 ==
|
|
:ejabberd_commands.execute_command(:add_contacts, [@user, @domain,
|
|
[{@user<>"1"<>@domain,
|
|
"group1",
|
|
"nick1"},
|
|
{@user<>"2"<>@domain,
|
|
"group2",
|
|
"nick2"}]
|
|
])
|
|
|
|
EjabberdAuthMock.create_user @user, @domain, @password
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource
|
|
EjabberdAuthMock.create_user @user<>"1", @domain, @password
|
|
EjabberdSmMock.connect_resource @user<>"1", @domain, @resource
|
|
EjabberdAuthMock.create_user @user<>"2", @domain, @password
|
|
|
|
# Add user1 & user2 in user's roster. Try also to add user0 that
|
|
# doesn't exists. Command is supposed to return number of added items.
|
|
assert 2 ==
|
|
:ejabberd_commands.execute_command(:add_contacts, [@user, @domain,
|
|
[{@user<>"0@"<>@domain,
|
|
"group0",
|
|
"nick0"},
|
|
{@user<>"1@"<>@domain,
|
|
"group1",
|
|
"nick1"},
|
|
{@user<>"2@"<>@domain,
|
|
"group2",
|
|
"nick2"}]
|
|
])
|
|
# Check that user1 & user2 are the only items in user's roster
|
|
result = ModRosterMock.get_roster(@user, @domain)
|
|
assert 2 == length result
|
|
opts1 = %{nick: "nick1", groups: ["group1"], subs: :both,
|
|
ask: :none, askmessage: ""}
|
|
assert Enum.member?(result, {{@user, @domain, @user<>"1@"<>@domain}, opts1})
|
|
opts2 = %{nick: "nick2", groups: ["group2"], subs: :both,
|
|
ask: :none, askmessage: ""}
|
|
assert Enum.member?(result, {{@user, @domain, @user<>"2@"<>@domain}, opts2})
|
|
|
|
# Check that user is the only item in user1's roster
|
|
assert [{{@user<>"1", @domain, @user<>"@"<>@domain}, %{opts1|:nick => ""}}] ==
|
|
ModRosterMock.get_roster(@user<>"1", @domain)
|
|
|
|
# Check that user is the only item in user2's roster
|
|
assert [{{@user<>"2", @domain, @user<>"@"<>@domain}, %{opts2|:nick => ""}}] ==
|
|
ModRosterMock.get_roster(@user<>"2", @domain)
|
|
|
|
|
|
# Check that the roster items user1 & user2 were pushed with subscription
|
|
# 'both' to the user online ressource
|
|
jid = :jlib.make_jid(@user, @domain, @resource)
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"1", @domain, ""}, :both}}])
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"2", @domain, ""}, :both}}])
|
|
|
|
# Check that the roster item user was pushed with subscription
|
|
# 'both' to the user1 online ressource
|
|
jid = :jlib.make_jid(@user<>"1", @domain, @resource)
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user, @domain, ""}, :both}}])
|
|
|
|
# Check that nothing else was pushed to online resources
|
|
assert 3 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[:_, :_,
|
|
{:broadcast, {:item, :_, :_}}])
|
|
|
|
# Remove user1 & user2 from user's roster. Try also to remove
|
|
# user0 that doesn't exists. Command is supposed to return number
|
|
# of removed items.
|
|
assert 2 ==
|
|
:ejabberd_commands.execute_command(:remove_contacts, [@user, @domain,
|
|
[@user<>"0@"<>@domain,
|
|
@user<>"1@"<>@domain,
|
|
@user<>"2@"<>@domain]
|
|
])
|
|
# Check that roster of user, user1 & user2 are empty
|
|
assert [] == ModRosterMock.get_roster(@user, @domain)
|
|
assert [] == ModRosterMock.get_roster(@user<>"1", @domain)
|
|
assert [] == ModRosterMock.get_roster(@user<>"2", @domain)
|
|
|
|
# Check that the roster items user1 & user2 were pushed with subscription
|
|
# 'none' to the user online ressource
|
|
jid = :jlib.make_jid(@user, @domain, @resource)
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"1", @domain, ""}, :none}}])
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"2", @domain, ""}, :none}}])
|
|
|
|
# Check that the roster item user was pushed with subscription
|
|
# 'none' to the user1 online ressource
|
|
jid = :jlib.make_jid(@user<>"1", @domain, @resource)
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user, @domain, ""}, :none}}])
|
|
|
|
# Check that nothing else was pushed to online resources
|
|
assert 6 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[:_, :_,
|
|
{:broadcast, {:item, :_, :_}}])
|
|
|
|
assert :meck.validate :ejabberd_sm
|
|
assert :meck.validate :ejabberd_auth
|
|
end
|
|
|
|
|
|
test "update_roster works" do
|
|
# user doesn't exists yet, command must fail
|
|
result =
|
|
:ejabberd_commands.execute_command(:update_roster,
|
|
[@user, @domain,
|
|
[{@user<>"1"<>@domain,
|
|
"group1",
|
|
"nick1"},
|
|
{@user<>"2"<>@domain,
|
|
"group2",
|
|
"nick2"}],
|
|
[]
|
|
])
|
|
assert :invalid_user == elem(result, 0)
|
|
|
|
EjabberdAuthMock.create_user @user, @domain, @password
|
|
EjabberdSmMock.connect_resource @user, @domain, @resource
|
|
EjabberdAuthMock.create_user @user<>"1", @domain, @password
|
|
EjabberdSmMock.connect_resource @user<>"1", @domain, @resource
|
|
EjabberdAuthMock.create_user @user<>"2", @domain, @password
|
|
EjabberdAuthMock.create_user @user<>"3", @domain, @password
|
|
|
|
assert :ok ==
|
|
:ejabberd_commands.execute_command(:update_roster,
|
|
[@user, @domain,
|
|
[{[{"username", @user<>"1"},
|
|
{"nick", "nick1"}]},
|
|
{[{"username", @user<>"2"},
|
|
{"nick", "nick2"},
|
|
{"subscription", "from"}]}],
|
|
[]])
|
|
|
|
|
|
# Check that user1 & user2 are the only items in user's roster
|
|
result = ModRosterMock.get_roster(@user, @domain)
|
|
|
|
assert 2 == length result
|
|
opts1 = %{nick: "nick1", groups: [""], subs: :both,
|
|
ask: :none, askmessage: ""}
|
|
assert Enum.member?(result, {{@user, @domain, @user<>"1@"<>@domain}, opts1})
|
|
opts2 = %{nick: "nick2", groups: [""], subs: :from,
|
|
ask: :none, askmessage: ""}
|
|
assert Enum.member?(result, {{@user, @domain, @user<>"2@"<>@domain}, opts2})
|
|
|
|
# Check that the roster items user1 & user2 were pushed with subscription
|
|
# 'both' to the user online ressource
|
|
jid = :jlib.make_jid(@user, @domain, @resource)
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"1", @domain, ""}, :both}}])
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"2", @domain, ""}, :from}}])
|
|
|
|
# Check that nothing else was pushed to online resources
|
|
assert 2 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[:_, :_,
|
|
{:broadcast, {:item, :_, :_}}])
|
|
|
|
# Add user3 & remove user1
|
|
assert :ok ==
|
|
:ejabberd_commands.execute_command(:update_roster,
|
|
[@user, @domain,
|
|
[{[{"username", @user<>"3"},
|
|
{"nick", "nick3"},
|
|
{"subscription", "to"}]}],
|
|
[{[{"username", @user<>"1"}]}]
|
|
])
|
|
|
|
# Check that user2 & user3 are the only items in user's roster
|
|
result = ModRosterMock.get_roster(@user, @domain)
|
|
assert 2 == length result
|
|
opts2 = %{nick: "nick2", groups: [""], subs: :from,
|
|
ask: :none, askmessage: ""}
|
|
assert Enum.member?(result, {{@user, @domain, @user<>"2@"<>@domain}, opts2})
|
|
opts1 = %{nick: "nick3", groups: [""], subs: :to,
|
|
ask: :none, askmessage: ""}
|
|
assert Enum.member?(result, {{@user, @domain, @user<>"3@"<>@domain}, opts1})
|
|
|
|
# Check that the roster items user1 & user3 were pushed with subscription
|
|
# 'none' & 'to' to the user online ressource
|
|
jid = :jlib.make_jid(@user, @domain, @resource)
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"1", @domain, ""}, :none}}])
|
|
assert 1 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[jid, jid,
|
|
{:broadcast, {:item, {@user<>"3", @domain, ""}, :to}}])
|
|
|
|
# Check that nothing else was pushed to online resources
|
|
assert 4 ==
|
|
:meck.num_calls(:ejabberd_sm, :route,
|
|
[:_, :_,
|
|
{:broadcast, {:item, :_, :_}}])
|
|
|
|
assert :meck.validate :ejabberd_sm
|
|
assert :meck.validate :ejabberd_auth
|
|
end
|
|
|
|
|
|
# kick_user command is defined in ejabberd_sm, move to extra?
|
|
# test "kick_user works" do
|
|
# assert 0 == :ejabberd_commands.execute_command(:num_resources,
|
|
# [@user, @domain])
|
|
# EjabberdSmMock.connect_resource(@user, @domain, @resource<>"1")
|
|
# EjabberdSmMock.connect_resource(@user, @domain, @resource<>"2")
|
|
# assert 2 ==
|
|
# :ejabberd_commands.execute_command(:kick_user, [@user, @domain])
|
|
# assert 0 == :ejabberd_commands.execute_command(:num_resources,
|
|
# [@user, @domain])
|
|
# assert :meck.validate :ejabberd_sm
|
|
# end
|
|
|
|
end
|