def setUp(self):
verbose = True
self.api = EjabberdAPIClient(host=HOST,
port=PORT,
username=USERNAME,
password=PASSWORD,
user_domain=XMPP_DOMAIN,
protocol=PROTOCOL,
verbose=VERBOSE)
self.assertIsNotNone(self.api)
def ejab():
from pyejabberd import EjabberdAPIClient
# client = EjabberdAPIClient(host='192.168.1.7', port=5222, username='******', password='******',
# user_domain='jos-macbook-air',
# protocol='http', verbose=True)
client = EjabberdAPIClient(host='localhost',
port=5222,
username='******',
password='******',
user_domain='ex',
protocol='http',
verbose=True)
registered_users = client.registered_users('localhost')
print(registered_users)
def test_from_string_incorrect_auth(self):
service_url = '%s://bla@%s:%s/%s' % (PROTOCOL, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_protocol(self):
service_url = 'test://%s:%s@%s:%s/%s' % (USERNAME, PASSWORD, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_auth(self):
service_url = '%s://bla@%s:%s/%s' % (PROTOCOL, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_protocol(self):
service_url = 'test://%s:%s@%s:%s/%s' % (USERNAME, PASSWORD, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_default_server_port(self):
service_url = '%s://%s:%s@%s/%s' % (PROTOCOL, USERNAME, PASSWORD, HOST, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertFalse(error_thrown)
self.assertIsNotNone(api)
self.assertEqual(api.port, XMLRPC_API_PORT)
def test_from_string_ok(self):
service_url = '%s://%s:%s@%s:%s/%s' % (PROTOCOL, USERNAME, PASSWORD,
HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertFalse(error_thrown)
self.assertIsNotNone(api)
def setUp(self):
verbose = True
self.api = EjabberdAPIClient(
host=HOST, port=PORT, username=USERNAME, password=PASSWORD, user_domain=XMPP_DOMAIN, protocol=PROTOCOL,
verbose=VERBOSE)
self.assertIsNotNone(self.api)
class EjabberdAPITests(TestCase):
def setUp(self):
verbose = True
self.api = EjabberdAPIClient(
host=HOST, port=PORT, username=USERNAME, password=PASSWORD, user_domain=XMPP_DOMAIN, protocol=PROTOCOL,
verbose=VERBOSE)
self.assertIsNotNone(self.api)
def test_testserver_unreachable(self):
self.assertFalse(ejabberd_testserver_is_up('%s://%s:%s' % (PROTOCOL, HOST, 31337)))
def test_from_string_ok(self):
service_url = '%s://%s:%s@%s:%s/%s' % (PROTOCOL, USERNAME, PASSWORD, HOST, PORT,
XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertFalse(error_thrown)
self.assertIsNotNone(api)
def test_from_string_incorrect_protocol(self):
service_url = 'test://%s:%s@%s:%s/%s' % (USERNAME, PASSWORD, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_auth(self):
service_url = '%s://bla@%s:%s/%s' % (PROTOCOL, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_default_server_port(self):
service_url = '%s://%s:%s@%s/%s' % (PROTOCOL, USERNAME, PASSWORD, HOST, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertFalse(error_thrown)
self.assertIsNotNone(api)
self.assertEqual(api.port, XMLRPC_API_PORT)
def test_from_string_incorrect_server(self):
service_url = '%s://%s:%s@%s:%s:bla/%s' % (PROTOCOL, USERNAME, PASSWORD, HOST, PORT,
XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_domain(self):
service_url = '%s://%s:%s@%s:%s/%s/bla' % (PROTOCOL, USERNAME, PASSWORD, HOST, PORT,
XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_echo(self):
sentence = '51@#211323$%^&*()üFße'
result = self.api.echo(sentence)
self.assertIsNotNone(result)
self.assertEqual(result, sentence)
def test_echo_no_auth(self):
class EchoNoAuth(Echo):
authenticate = False
result = self.api._call_api(EchoNoAuth, sentence='foo')
self.assertEqual('foo', result)
def test_missing_argument(self):
missing_argument = False
try:
self.api._validate_and_serialize_arguments(Echo, [])
except IllegalArgumentError:
missing_argument = True
self.assertTrue(missing_argument)
def test_report_method_call(self):
self.api.verbose = False
report = self.api._report_method_call('echo', {'sentence': 'foo'})
self.assertEqual(report, None)
self.api.verbose = True
report = self.api._report_method_call('echo', {'sentence': 'foo'})
self.assertEqual(report, '===> echo(sentence=foo)')
def test_registered_users(self):
result = self.api.registered_users(XMPP_DOMAIN)
self.assertTrue(isinstance(result, (list, tuple)))
registered_users = self.api.registered_users(host=XMPP_DOMAIN)
registered_users = [struct.get('username') for struct in registered_users]
self.assertTrue('admin' in registered_users)
def test_register_unregister_user(self):
with create_test_user(self.api, 'testuser_1', host=XMPP_DOMAIN) as username:
registered_users = self.api.registered_users(host=XMPP_DOMAIN)
registered_users = [struct.get('username') for struct in registered_users]
self.assertTrue(username in registered_users)
def test_username_already_exists(self):
with create_test_user(self.api, 'testuser_2', host=XMPP_DOMAIN) as username:
error_thrown = False
try:
with create_test_user(self.api, 'testuser_2', host=XMPP_DOMAIN) as username2:
self.assertEqual(username2, username)
except UserAlreadyRegisteredError:
error_thrown = True
self.assertTrue(error_thrown)
def test_change_check_password(self):
with create_test_user(self.api, 'testuser_3', host=XMPP_DOMAIN, password='******') as username:
result = self.api.check_password_hash(username, host=XMPP_DOMAIN, password='******')
self.assertTrue(result)
result = self.api.check_password_hash(username, host=XMPP_DOMAIN, password='******')
self.assertFalse(result)
result = self.api.change_password(username, host=XMPP_DOMAIN, newpass='******')
self.assertTrue(result)
result = self.api.check_password_hash(username, host=XMPP_DOMAIN, password='******')
self.assertFalse(result)
result = self.api.check_password_hash(username, host=XMPP_DOMAIN, password='******')
self.assertTrue(result)
def test_set_nickname(self):
with create_test_user(self.api, 'testuser_4', host=XMPP_DOMAIN) as username:
result = self.api.set_nickname(username, host=XMPP_DOMAIN, nickname='blabla')
self.assertTrue(result)
def test_connected_users(self):
result = self.api.connected_users()
self.assertTrue(isinstance(result, (list)))
def test_connected_users_info(self):
result = self.api.connected_users_info()
self.assertTrue(isinstance(result, (list)))
def test_connected_users_number(self):
result = self.api.connected_users_number()
self.assertTrue(isinstance(result, (int)))
def test_user_sessions_info(self):
result = self.api.user_sessions_info('admin', XMPP_DOMAIN)
self.assertTrue(isinstance(result, (list)))
def test_user_sessions_info_process_session_info(self):
response = [{'session': [{'connection': 'fake'},
{'ip': '127.0.0.1'},
{'port': 31337},
{'priority': 0},
{'node': '*****@*****.**'},
{'uptime': 1},
{'status': 'bar'},
{'resource': 'foo'},
{'statustext': 'bar'}]}]
user_session_info = UserSessionsInfo()
actual_result = user_session_info.process_sessions_info(response)
expected_result = [{u'resource': u'foo',
u'node': u'*****@*****.**',
u'statustext': u'bar',
u'status': u'bar',
u'ip': u'127.0.0.1',
u'connection': u'fake',
u'uptime': 1,
u'port': 31337,
u'priority': 0}]
self.assertEqual(expected_result[0]['port'], actual_result[0]['port'])
def test_create_destroy_room(self):
with create_test_room(self.api, 'testroom_1', service=MUC_SERVICE, host=XMPP_DOMAIN,
test_existence=False) as room:
online_rooms = self.api.muc_online_rooms()
full_name = '%s@%s' % (room, MUC_SERVICE)
self.assertTrue(full_name in online_rooms)
#def test_get_room_options(self):
# with create_test_room(self.api, 'testroom_2', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
# result = self.api.get_room_options(room, service=MUC_SERVICE)
# self.assertTrue(isinstance(result, dict))
def test_room_option_allow_change_subj(self):
with create_test_room(self.api, 'testroom_3', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_change_subj, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_change_subj, value=True))
def test_room_option_allow_private_messages(self):
with create_test_room(self.api, 'testroom_4', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_private_messages, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_private_messages, value=True))
def test_room_option_allow_query_users(self):
with create_test_room(self.api, 'testroom_5', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_query_users, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_query_users, value=True))
def test_room_option_allow_user_invites(self):
with create_test_room(self.api, 'testroom_6', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_user_invites, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_user_invites, value=True))
def test_room_option_allow_visitor_nickchange(self):
with create_test_room(self.api, 'testroom_7', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_visitor_nickchange, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_visitor_nickchange, value=True))
def test_room_option_allow_visitor_status(self):
with create_test_room(self.api, 'testroom_8', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_visitor_status, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_visitor_status, value=True))
def test_room_option_anonymous(self):
with create_test_room(self.api, 'testroom_9', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.anonymous, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.anonymous, value=True))
def test_room_option_captcha_protected(self):
with create_test_room(self.api, 'testroom_10', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.captcha_protected, value=True))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.captcha_protected, value=False))
def test_room_option_logging(self):
with create_test_room(self.api, 'testroom_11', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.logging, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.logging, value=True))
def test_room_option_max_users(self):
with create_test_room(self.api, 'testroom_12', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.max_users, value=10))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.max_users, value=100))
def test_room_option_members_by_default(self):
with create_test_room(self.api, 'testroom_13', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.members_by_default, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.members_by_default, value=True))
def test_room_option_members_only(self):
with create_test_room(self.api, 'testroom_14', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.members_only, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.members_only, value=True))
def test_room_option_moderated(self):
with create_test_room(self.api, 'testroom_15', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.moderated, value=True))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.moderated, value=False))
def test_room_option_password(self):
with create_test_room(self.api, 'testroom_16', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.password, value='abcdefg'))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.password, value='51@#211323$%^&*()üFße'))
def test_room_option_password_protected(self):
with create_test_room(self.api, 'testroom_17', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.password_protected, value=True))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.password_protected, value=False))
def test_room_option_persistent(self):
with create_test_room(self.api, 'testroom_18', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.persistent, value=True))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.persistent, value=False))
def test_room_option_public(self):
with create_test_room(self.api, 'testroom_19', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.public, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.public, value=True))
def test_room_option_public_list(self):
with create_test_room(self.api, 'testroom_20', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.public_list, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.public_list, value=True))
def test_room_option_title(self):
with create_test_room(self.api, 'testroom_21', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.title, value='51@#211323$%^&*()üFße'))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.title, value='abcdefg'))
def test_room_option_allow_private_messages_from_visitors(self):
with create_test_room(self.api, 'testroom_22', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_private_messages_from_visitors,
value=AllowVisitorPrivateMessage.nobody))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_private_messages_from_visitors,
value=AllowVisitorPrivateMessage.moderators))
def test_set_affiliation_outcast(self):
with create_test_user(self.api, 'testuser_5', host=XMPP_DOMAIN) as username:
with create_test_room(self.api, 'testroom_23', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(room, service=MUC_SERVICE, jid=jid,
affiliation=Affiliation.outcast))
def test_set_affiliation_none(self):
with create_test_user(self.api, 'testuser_6', host=XMPP_DOMAIN) as username:
with create_test_room(self.api, 'testroom_24', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(room, service=MUC_SERVICE, jid=jid,
affiliation=Affiliation.none))
def test_set_affiliation_member(self):
with create_test_user(self.api, 'testuser_7', host=XMPP_DOMAIN) as username:
with create_test_room(self.api, 'testroom_25', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(room, service=MUC_SERVICE, jid=jid,
affiliation=Affiliation.member))
def test_set_affiliation_admin(self):
with create_test_user(self.api, 'testuser_8', host=XMPP_DOMAIN) as username:
with create_test_room(self.api, 'testroom_26', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(room, service=MUC_SERVICE, jid=jid,
affiliation=Affiliation.admin))
def test_set_affiliation_owner(self):
with create_test_user(self.api, 'testuser_9', host=XMPP_DOMAIN) as username:
with create_test_room(self.api, 'testroom_28', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(room, service=MUC_SERVICE, jid=jid,
affiliation=Affiliation.owner))
def test_get_affiliations(self):
# Heavy nesting but at least it's compatible with python 2.6
with create_test_user(self.api, 'testuser_10', host=XMPP_DOMAIN) as username1:
with create_test_user(self.api, 'testuser_11', host=XMPP_DOMAIN) as username2:
with create_test_user(self.api, 'testuser_12', host=XMPP_DOMAIN) as username3:
with create_test_user(self.api, 'testuser_13', host=XMPP_DOMAIN) as username4:
with create_test_user(self.api, 'testuser_14', host=XMPP_DOMAIN) as username5:
with create_test_room(self.api, 'testroom_29', service=MUC_SERVICE, host=XMPP_DOMAIN
) as room:
usernames = [username1, username2, username3, username4, username5]
input_affiliations = [Affiliation.outcast, Affiliation.none, Affiliation.member,
Affiliation.admin, Affiliation.owner]
for i in range(len(usernames)):
jid = '%s@%s' % (usernames[i], XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(
room, service=MUC_SERVICE, jid=jid, affiliation=input_affiliations[i]))
output_affiliations = self.api.get_room_affiliations(room, service=MUC_SERVICE)
self.assertEqual(len(output_affiliations), 4)
affiliations_dict = {}
for affiliation in output_affiliations:
self.assertEqual(affiliation['domain'], XMPP_DOMAIN)
self.assertEqual(affiliation['reason'], '')
affiliations_dict[affiliation['username']] = affiliation['affiliation']
for i in range(len(usernames)):
username = usernames[i]
expected_affiliation = input_affiliations[i]
if expected_affiliation == Affiliation.none:
self.assertTrue(username not in affiliations_dict)
continue
self.assertEqual(affiliations_dict[username], expected_affiliation)
for i in range(len(usernames)):
jid = '%s@%s' % (usernames[i], XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(
room, service=MUC_SERVICE, jid=jid, affiliation=Affiliation.none))
output_affiliations = self.api.get_room_affiliations(room, service=MUC_SERVICE)
self.assertEqual(len(output_affiliations), 0)
def test_roster_commands(self):
# create test users
try:
user1_created = create_test_user(self.api, 'testuser_15', host=XMPP_DOMAIN)
except UserAlreadyRegisteredError:
user1_created = False
try:
user2_created = create_test_user(self.api, 'testuser_16', host=XMPP_DOMAIN)
except UserAlreadyRegisteredError:
user2_created = False
# if users already exist delete the second user from the first user's roster
if user1_created == False and user2_created == False:
delete_rosteritem = self.api.delete_rosteritem('testuser_15', XMPP_DOMAIN, 'testuser_16', XMPP_DOMAIN)
self.assertTrue(delete_rosteritem)
# check if the first user's roster is empty
roster = self.api.get_roster('testuser_15', XMPP_DOMAIN)
self.assertEqual(roster, [])
# add the second user to the first user's roster
add_rosteritem = self.api.add_rosteritem('testuser_15', XMPP_DOMAIN, 'testuser_16', XMPP_DOMAIN, 'testuser_16', 'buddies', 'both')
self.assertTrue(add_rosteritem)
# check if the first user's roster contains the second user
roster = self.api.get_roster('testuser_15', XMPP_DOMAIN)
self.assertEqual(roster[0]['jid'], 'testuser_16@{0}'.format(XMPP_DOMAIN))
self.assertEqual(roster[0]['group'], 'buddies')
# add the second user to the first user's roster again, now to a different group
add_rosteritem = self.api.add_rosteritem('testuser_15', XMPP_DOMAIN, 'testuser_16', XMPP_DOMAIN, 'testuser_16', 'friends', 'both')
self.assertTrue(add_rosteritem)
# check if the first user's roster contains the second user in the different group
roster = self.api.get_roster('testuser_15', XMPP_DOMAIN)
self.assertEqual(roster[0]['jid'], 'testuser_16@{0}'.format(XMPP_DOMAIN))
self.assertEqual(roster[0]['group'], 'friends')
# delete the second user from the first user's roster
delete_rosteritem = self.api.delete_rosteritem('testuser_15', XMPP_DOMAIN, 'testuser_16', XMPP_DOMAIN)
self.assertTrue(delete_rosteritem)
# check if the first user's roster is empty
roster = self.api.get_roster('testuser_15', XMPP_DOMAIN)
self.assertEqual(roster, [])
def test_check_account(self):
with create_test_user(self.api, 'testuser_17', host=XMPP_DOMAIN) as username:
check_account = self.api.check_account(username, XMPP_DOMAIN)
self.assertTrue(check_account)
self.api.unregister(username, host=XMPP_DOMAIN)
check_account = self.api.check_account(username, XMPP_DOMAIN)
self.assertFalse(check_account)
def test_kick_user(self):
kick_user = self.api.kick_user('admin', XMPP_DOMAIN)
self.assertEqual(kick_user, 0)
def test_kick_session(self):
kick_session = self.api.kick_session('admin', XMPP_DOMAIN, 'foo', 'bar')
self.assertTrue(kick_session)
class EjabberdAPITests(TestCase):
def setUp(self):
verbose = True
self.api = EjabberdAPIClient(
host=HOST, port=PORT, username=USERNAME, password=PASSWORD, user_domain=XMPP_DOMAIN, protocol=PROTOCOL,
verbose=VERBOSE)
self.assertIsNotNone(self.api)
def test_from_string_ok(self):
service_url = '%s://%s:%s@%s:%s/%s' % (PROTOCOL, USERNAME, PASSWORD, HOST, PORT,
XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertFalse(error_thrown)
self.assertIsNotNone(api)
def test_from_string_incorrect_protocol(self):
service_url = 'test://%s:%s@%s:%s/%s' % (USERNAME, PASSWORD, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_auth(self):
service_url = '%s://bla@%s:%s/%s' % (PROTOCOL, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_default_server_port(self):
service_url = '%s://%s:%s@%s/%s' % (PROTOCOL, USERNAME, PASSWORD, HOST, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertFalse(error_thrown)
self.assertIsNotNone(api)
self.assertEqual(api.port, XMLRPC_API_PORT)
def test_from_string_incorrect_server(self):
service_url = '%s://%s:%s@%s:%s:bla/%s' % (PROTOCOL, USERNAME, PASSWORD, HOST, PORT,
XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_domain(self):
service_url = '%s://%s:%s@%s:%s/%s/bla' % (PROTOCOL, USERNAME, PASSWORD, HOST, PORT,
XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_echo(self):
sentence = '51@#211323$%^&*()üFße'
result = self.api.echo(sentence)
self.assertIsNotNone(result)
self.assertEqual(result, sentence)
def test_registered_users(self):
result = self.api.registered_users(XMPP_DOMAIN)
self.assertTrue(isinstance(result, (list, tuple)))
registered_users = self.api.registered_users(host=XMPP_DOMAIN)
registered_users = [struct.get('username') for struct in registered_users]
self.assertTrue('admin' in registered_users)
def test_register_unregister_user(self):
with create_test_user(self.api, 'testuser_1', host=XMPP_DOMAIN) as username:
registered_users = self.api.registered_users(host=XMPP_DOMAIN)
registered_users = [struct.get('username') for struct in registered_users]
self.assertTrue(username in registered_users)
def test_username_already_exists(self):
with create_test_user(self.api, 'testuser_2', host=XMPP_DOMAIN) as username:
error_thrown = False
try:
with create_test_user(self.api, 'testuser_2', host=XMPP_DOMAIN) as username2:
self.assertEqual(username2, username)
except UserAlreadyRegisteredError:
error_thrown = True
self.assertTrue(error_thrown)
def test_change_check_password(self):
with create_test_user(self.api, 'testuser_3', host=XMPP_DOMAIN, password='******') as username:
result = self.api.check_password_hash(username, host=XMPP_DOMAIN, password='******')
self.assertTrue(result)
result = self.api.check_password_hash(username, host=XMPP_DOMAIN, password='******')
self.assertFalse(result)
result = self.api.change_password(username, host=XMPP_DOMAIN, newpass='******')
self.assertTrue(result)
result = self.api.check_password_hash(username, host=XMPP_DOMAIN, password='******')
self.assertFalse(result)
result = self.api.check_password_hash(username, host=XMPP_DOMAIN, password='******')
self.assertTrue(result)
def test_set_nickname(self):
with create_test_user(self.api, 'testuser_4', host=XMPP_DOMAIN) as username:
result = self.api.set_nickname(username, host=XMPP_DOMAIN, nickname='blabla')
self.assertTrue(result)
def test_connected_users(self):
result = self.api.connected_users()
self.assertTrue(isinstance(result, (list)))
def test_connected_users_info(self):
result = self.api.connected_users_info()
self.assertTrue(isinstance(result, (list)))
def test_connected_users_number(self):
result = self.api.connected_users_number()
self.assertTrue(isinstance(result, (int)))
def test_user_sessions_info(self):
result = self.api.user_sessions_info('admin', XMPP_DOMAIN)
self.assertTrue(isinstance(result, (list)))
def test_create_destroy_room(self):
with create_test_room(self.api, 'testroom_1', service=MUC_SERVICE, host=XMPP_DOMAIN,
test_existence=False) as room:
online_rooms = self.api.muc_online_rooms()
full_name = '%s@%s' % (room, MUC_SERVICE)
self.assertTrue(full_name in online_rooms)
def test_get_room_options(self):
with create_test_room(self.api, 'testroom_2', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
result = self.api.get_room_options(room, service=MUC_SERVICE)
self.assertTrue(isinstance(result, dict))
def test_room_option_allow_change_subj(self):
with create_test_room(self.api, 'testroom_3', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_change_subj, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_change_subj, value=True))
def test_room_option_allow_private_messages(self):
with create_test_room(self.api, 'testroom_4', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_private_messages, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_private_messages, value=True))
def test_room_option_allow_query_users(self):
with create_test_room(self.api, 'testroom_5', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_query_users, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_query_users, value=True))
def test_room_option_allow_user_invites(self):
with create_test_room(self.api, 'testroom_6', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_user_invites, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_user_invites, value=True))
def test_room_option_allow_visitor_nickchange(self):
with create_test_room(self.api, 'testroom_7', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_visitor_nickchange, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_visitor_nickchange, value=True))
def test_room_option_allow_visitor_status(self):
with create_test_room(self.api, 'testroom_8', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_visitor_status, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_visitor_status, value=True))
def test_room_option_anonymous(self):
with create_test_room(self.api, 'testroom_9', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.anonymous, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.anonymous, value=True))
def test_room_option_captcha_protected(self):
with create_test_room(self.api, 'testroom_10', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.captcha_protected, value=True))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.captcha_protected, value=False))
def test_room_option_logging(self):
with create_test_room(self.api, 'testroom_11', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.logging, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.logging, value=True))
def test_room_option_max_users(self):
with create_test_room(self.api, 'testroom_12', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.max_users, value=10))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.max_users, value=100))
def test_room_option_members_by_default(self):
with create_test_room(self.api, 'testroom_13', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.members_by_default, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.members_by_default, value=True))
def test_room_option_members_only(self):
with create_test_room(self.api, 'testroom_14', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.members_only, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.members_only, value=True))
def test_room_option_moderated(self):
with create_test_room(self.api, 'testroom_15', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.moderated, value=True))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.moderated, value=False))
def test_room_option_password(self):
with create_test_room(self.api, 'testroom_16', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.password, value='abcdefg'))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.password, value='51@#211323$%^&*()üFße'))
def test_room_option_password_protected(self):
with create_test_room(self.api, 'testroom_17', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.password_protected, value=True))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.password_protected, value=False))
def test_room_option_persistent(self):
with create_test_room(self.api, 'testroom_18', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.persistent, value=True))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.persistent, value=False))
def test_room_option_public(self):
with create_test_room(self.api, 'testroom_19', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.public, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.public, value=True))
def test_room_option_public_list(self):
with create_test_room(self.api, 'testroom_20', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.public_list, value=False))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.public_list, value=True))
def test_room_option_title(self):
with create_test_room(self.api, 'testroom_21', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.title, value='51@#211323$%^&*()üFße'))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.title, value='abcdefg'))
def test_room_option_allow_private_messages_from_visitors(self):
with create_test_room(self.api, 'testroom_22', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_private_messages_from_visitors,
value=AllowVisitorPrivateMessage.nobody))
self.assertTrue(self.api.change_room_option(
room, service=MUC_SERVICE, option=MUCRoomOption.allow_private_messages_from_visitors,
value=AllowVisitorPrivateMessage.moderators))
def test_set_affiliation_outcast(self):
with create_test_user(self.api, 'testuser_5', host=XMPP_DOMAIN) as username:
with create_test_room(self.api, 'testroom_23', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(room, service=MUC_SERVICE, jid=jid,
affiliation=Affiliation.outcast))
def test_set_affiliation_none(self):
with create_test_user(self.api, 'testuser_6', host=XMPP_DOMAIN) as username:
with create_test_room(self.api, 'testroom_24', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(room, service=MUC_SERVICE, jid=jid,
affiliation=Affiliation.none))
def test_set_affiliation_member(self):
with create_test_user(self.api, 'testuser_7', host=XMPP_DOMAIN) as username:
with create_test_room(self.api, 'testroom_25', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(room, service=MUC_SERVICE, jid=jid,
affiliation=Affiliation.member))
def test_set_affiliation_admin(self):
with create_test_user(self.api, 'testuser_8', host=XMPP_DOMAIN) as username:
with create_test_room(self.api, 'testroom_26', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(room, service=MUC_SERVICE, jid=jid,
affiliation=Affiliation.admin))
def test_set_affiliation_owner(self):
with create_test_user(self.api, 'testuser_9', host=XMPP_DOMAIN) as username:
with create_test_room(self.api, 'testroom_28', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(room, service=MUC_SERVICE, jid=jid,
affiliation=Affiliation.owner))
def test_get_affiliations(self):
# Heavy nesting but at least it's compatible with python 2.6
with create_test_user(self.api, 'testuser_10', host=XMPP_DOMAIN) as username1:
with create_test_user(self.api, 'testuser_11', host=XMPP_DOMAIN) as username2:
with create_test_user(self.api, 'testuser_12', host=XMPP_DOMAIN) as username3:
with create_test_user(self.api, 'testuser_13', host=XMPP_DOMAIN) as username4:
with create_test_user(self.api, 'testuser_14', host=XMPP_DOMAIN) as username5:
with create_test_room(self.api, 'testroom_29', service=MUC_SERVICE, host=XMPP_DOMAIN
) as room:
usernames = [username1, username2, username3, username4, username5]
input_affiliations = [Affiliation.outcast, Affiliation.none, Affiliation.member,
Affiliation.admin, Affiliation.owner]
for i in range(len(usernames)):
jid = '%s@%s' % (usernames[i], XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(
room, service=MUC_SERVICE, jid=jid, affiliation=input_affiliations[i]))
output_affiliations = self.api.get_room_affiliations(room, service=MUC_SERVICE)
self.assertEqual(len(output_affiliations), 4)
affiliations_dict = {}
for affiliation in output_affiliations:
self.assertEqual(affiliation['domain'], XMPP_DOMAIN)
self.assertEqual(affiliation['reason'], '')
affiliations_dict[affiliation['username']] = affiliation['affiliation']
for i in range(len(usernames)):
username = usernames[i]
expected_affiliation = input_affiliations[i]
if expected_affiliation == Affiliation.none:
self.assertTrue(username not in affiliations_dict)
continue
self.assertEqual(affiliations_dict[username], expected_affiliation)
for i in range(len(usernames)):
jid = '%s@%s' % (usernames[i], XMPP_DOMAIN)
self.assertTrue(self.api.set_room_affiliation(
room, service=MUC_SERVICE, jid=jid, affiliation=Affiliation.none))
output_affiliations = self.api.get_room_affiliations(room, service=MUC_SERVICE)
self.assertEqual(len(output_affiliations), 0)
class EjabberdAPITests(TestCase):
def setUp(self):
verbose = True
self.api = EjabberdAPIClient(host=HOST,
port=PORT,
username=USERNAME,
password=PASSWORD,
user_domain=XMPP_DOMAIN,
protocol=PROTOCOL,
verbose=VERBOSE)
self.assertIsNotNone(self.api)
def test_testserver_unreachable(self):
self.assertFalse(
ejabberd_testserver_is_up('%s://%s:%s' % (PROTOCOL, HOST, 31337)))
def test_from_string_ok(self):
service_url = '%s://%s:%s@%s:%s/%s' % (PROTOCOL, USERNAME, PASSWORD,
HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertFalse(error_thrown)
self.assertIsNotNone(api)
def test_from_string_incorrect_protocol(self):
service_url = 'test://%s:%s@%s:%s/%s' % (USERNAME, PASSWORD, HOST,
PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_auth(self):
service_url = '%s://bla@%s:%s/%s' % (PROTOCOL, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_default_server_port(self):
service_url = '%s://%s:%s@%s/%s' % (PROTOCOL, USERNAME, PASSWORD, HOST,
XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertFalse(error_thrown)
self.assertIsNotNone(api)
self.assertEqual(api.port, XMLRPC_API_PORT)
def test_from_string_incorrect_server(self):
service_url = '%s://%s:%s@%s:%s:bla/%s' % (
PROTOCOL, USERNAME, PASSWORD, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_domain(self):
service_url = '%s://%s:%s@%s:%s/%s/bla' % (
PROTOCOL, USERNAME, PASSWORD, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_echo(self):
sentence = '51@#211323$%^&*()üFße'
result = self.api.echo(sentence)
self.assertIsNotNone(result)
self.assertEqual(result, sentence)
def test_echo_no_auth(self):
class EchoNoAuth(Echo):
authenticate = False
result = self.api._call_api(EchoNoAuth, sentence='foo')
self.assertEqual('foo', result)
def test_missing_argument(self):
missing_argument = False
try:
self.api._validate_and_serialize_arguments(Echo, [])
except IllegalArgumentError:
missing_argument = True
self.assertTrue(missing_argument)
def test_report_method_call(self):
self.api.verbose = False
report = self.api._report_method_call('echo', {'sentence': 'foo'})
self.assertEqual(report, None)
self.api.verbose = True
report = self.api._report_method_call('echo', {'sentence': 'foo'})
self.assertEqual(report, '===> echo(sentence=foo)')
def test_registered_users(self):
result = self.api.registered_users(XMPP_DOMAIN)
self.assertTrue(isinstance(result, (list, tuple)))
registered_users = self.api.registered_users(host=XMPP_DOMAIN)
registered_users = [
struct.get('username') for struct in registered_users
]
self.assertTrue('admin' in registered_users)
def test_register_unregister_user(self):
with create_test_user(self.api, 'testuser_1',
host=XMPP_DOMAIN) as username:
registered_users = self.api.registered_users(host=XMPP_DOMAIN)
registered_users = [
struct.get('username') for struct in registered_users
]
self.assertTrue(username in registered_users)
def test_username_already_exists(self):
with create_test_user(self.api, 'testuser_2',
host=XMPP_DOMAIN) as username:
error_thrown = False
try:
with create_test_user(self.api, 'testuser_2',
host=XMPP_DOMAIN) as username2:
self.assertEqual(username2, username)
except UserAlreadyRegisteredError:
error_thrown = True
self.assertTrue(error_thrown)
def test_change_check_password(self):
with create_test_user(self.api,
'testuser_3',
host=XMPP_DOMAIN,
password='******') as username:
result = self.api.check_password_hash(username,
host=XMPP_DOMAIN,
password='******')
self.assertTrue(result)
result = self.api.check_password_hash(username,
host=XMPP_DOMAIN,
password='******')
self.assertFalse(result)
result = self.api.change_password(username,
host=XMPP_DOMAIN,
newpass='******')
self.assertTrue(result)
result = self.api.check_password_hash(username,
host=XMPP_DOMAIN,
password='******')
self.assertFalse(result)
result = self.api.check_password_hash(username,
host=XMPP_DOMAIN,
password='******')
self.assertTrue(result)
def test_set_nickname(self):
with create_test_user(self.api, 'testuser_4',
host=XMPP_DOMAIN) as username:
result = self.api.set_nickname(username,
host=XMPP_DOMAIN,
nickname='blabla')
self.assertTrue(result)
def test_connected_users(self):
result = self.api.connected_users()
self.assertTrue(isinstance(result, (list)))
def test_connected_users_info(self):
result = self.api.connected_users_info()
self.assertTrue(isinstance(result, (list)))
def test_connected_users_number(self):
result = self.api.connected_users_number()
self.assertTrue(isinstance(result, (int)))
def test_user_sessions_info(self):
result = self.api.user_sessions_info('admin', XMPP_DOMAIN)
self.assertTrue(isinstance(result, (list)))
def test_user_sessions_info_process_session_info(self):
response = [{
'session': [{
'connection': 'fake'
}, {
'ip': '127.0.0.1'
}, {
'port': 31337
}, {
'priority': 0
}, {
'node': '*****@*****.**'
}, {
'uptime': 1
}, {
'status': 'bar'
}, {
'resource': 'foo'
}, {
'statustext': 'bar'
}]
}]
user_session_info = UserSessionsInfo()
actual_result = user_session_info.process_sessions_info(response)
expected_result = [{
u'resource': u'foo',
u'node': u'*****@*****.**',
u'statustext': u'bar',
u'status': u'bar',
u'ip': u'127.0.0.1',
u'connection': u'fake',
u'uptime': 1,
u'port': 31337,
u'priority': 0
}]
self.assertEqual(expected_result[0]['port'], actual_result[0]['port'])
def test_create_destroy_room(self):
with create_test_room(self.api,
'testroom_1',
service=MUC_SERVICE,
host=XMPP_DOMAIN,
test_existence=False) as room:
online_rooms = self.api.muc_online_rooms()
full_name = '%s@%s' % (room, MUC_SERVICE)
self.assertTrue(full_name in online_rooms)
#def test_get_room_options(self):
# with create_test_room(self.api, 'testroom_2', service=MUC_SERVICE, host=XMPP_DOMAIN) as room:
# result = self.api.get_room_options(room, service=MUC_SERVICE)
# self.assertTrue(isinstance(result, dict))
def test_room_option_allow_change_subj(self):
with create_test_room(self.api,
'testroom_3',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_change_subj,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_change_subj,
value=True))
def test_room_option_allow_private_messages(self):
with create_test_room(self.api,
'testroom_4',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_private_messages,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_private_messages,
value=True))
def test_room_option_allow_query_users(self):
with create_test_room(self.api,
'testroom_5',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_query_users,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_query_users,
value=True))
def test_room_option_allow_user_invites(self):
with create_test_room(self.api,
'testroom_6',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_user_invites,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_user_invites,
value=True))
def test_room_option_allow_visitor_nickchange(self):
with create_test_room(self.api,
'testroom_7',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_visitor_nickchange,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_visitor_nickchange,
value=True))
def test_room_option_allow_visitor_status(self):
with create_test_room(self.api,
'testroom_8',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_visitor_status,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_visitor_status,
value=True))
def test_room_option_anonymous(self):
with create_test_room(self.api,
'testroom_9',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.anonymous,
value=False))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.anonymous,
value=True))
def test_room_option_captcha_protected(self):
with create_test_room(self.api,
'testroom_10',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.captcha_protected,
value=True))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.captcha_protected,
value=False))
def test_room_option_logging(self):
with create_test_room(self.api,
'testroom_11',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.logging,
value=False))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.logging,
value=True))
def test_room_option_max_users(self):
with create_test_room(self.api,
'testroom_12',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.max_users,
value=10))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.max_users,
value=100))
def test_room_option_members_by_default(self):
with create_test_room(self.api,
'testroom_13',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.members_by_default,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.members_by_default,
value=True))
def test_room_option_members_only(self):
with create_test_room(self.api,
'testroom_14',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.members_only,
value=False))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.members_only,
value=True))
def test_room_option_moderated(self):
with create_test_room(self.api,
'testroom_15',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.moderated,
value=True))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.moderated,
value=False))
def test_room_option_password(self):
with create_test_room(self.api,
'testroom_16',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.password,
value='abcdefg'))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.password,
value='51@#211323$%^&*()üFße'))
def test_room_option_password_protected(self):
with create_test_room(self.api,
'testroom_17',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.password_protected,
value=True))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.password_protected,
value=False))
def test_room_option_persistent(self):
with create_test_room(self.api,
'testroom_18',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.persistent,
value=True))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.persistent,
value=False))
def test_room_option_public(self):
with create_test_room(self.api,
'testroom_19',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.public,
value=False))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.public,
value=True))
def test_room_option_public_list(self):
with create_test_room(self.api,
'testroom_20',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.public_list,
value=False))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.public_list,
value=True))
def test_room_option_title(self):
with create_test_room(self.api,
'testroom_21',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.title,
value='51@#211323$%^&*()üFße'))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.title,
value='abcdefg'))
def test_room_option_allow_private_messages_from_visitors(self):
with create_test_room(self.api,
'testroom_22',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_private_messages_from_visitors,
value=AllowVisitorPrivateMessage.nobody))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_private_messages_from_visitors,
value=AllowVisitorPrivateMessage.moderators))
def test_set_affiliation_outcast(self):
with create_test_user(self.api, 'testuser_5',
host=XMPP_DOMAIN) as username:
with create_test_room(self.api,
'testroom_23',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.outcast))
def test_set_affiliation_none(self):
with create_test_user(self.api, 'testuser_6',
host=XMPP_DOMAIN) as username:
with create_test_room(self.api,
'testroom_24',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.none))
def test_set_affiliation_member(self):
with create_test_user(self.api, 'testuser_7',
host=XMPP_DOMAIN) as username:
with create_test_room(self.api,
'testroom_25',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.member))
def test_set_affiliation_admin(self):
with create_test_user(self.api, 'testuser_8',
host=XMPP_DOMAIN) as username:
with create_test_room(self.api,
'testroom_26',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.admin))
def test_set_affiliation_owner(self):
with create_test_user(self.api, 'testuser_9',
host=XMPP_DOMAIN) as username:
with create_test_room(self.api,
'testroom_28',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.owner))
def test_get_affiliations(self):
# Heavy nesting but at least it's compatible with python 2.6
with create_test_user(self.api, 'testuser_10',
host=XMPP_DOMAIN) as username1:
with create_test_user(self.api, 'testuser_11',
host=XMPP_DOMAIN) as username2:
with create_test_user(self.api,
'testuser_12',
host=XMPP_DOMAIN) as username3:
with create_test_user(self.api,
'testuser_13',
host=XMPP_DOMAIN) as username4:
with create_test_user(self.api,
'testuser_14',
host=XMPP_DOMAIN) as username5:
with create_test_room(self.api,
'testroom_29',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
usernames = [
username1, username2, username3, username4,
username5
]
input_affiliations = [
Affiliation.outcast, Affiliation.none,
Affiliation.member, Affiliation.admin,
Affiliation.owner
]
for i in range(len(usernames)):
jid = '%s@%s' % (usernames[i], XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=input_affiliations[i]))
output_affiliations = self.api.get_room_affiliations(
room, service=MUC_SERVICE)
self.assertEqual(len(output_affiliations), 4)
affiliations_dict = {}
for affiliation in output_affiliations:
self.assertEqual(affiliation['domain'],
XMPP_DOMAIN)
self.assertEqual(affiliation['reason'], '')
affiliations_dict[
affiliation['username']] = affiliation[
'affiliation']
for i in range(len(usernames)):
username = usernames[i]
expected_affiliation = input_affiliations[
i]
if expected_affiliation == Affiliation.none:
self.assertTrue(
username not in affiliations_dict)
continue
self.assertEqual(
affiliations_dict[username],
expected_affiliation)
for i in range(len(usernames)):
jid = '%s@%s' % (usernames[i], XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.none))
output_affiliations = self.api.get_room_affiliations(
room, service=MUC_SERVICE)
self.assertEqual(len(output_affiliations), 0)
def test_roster_commands(self):
# create test users
try:
user1_created = create_test_user(self.api,
'testuser_15',
host=XMPP_DOMAIN)
except UserAlreadyRegisteredError:
user1_created = False
try:
user2_created = create_test_user(self.api,
'testuser_16',
host=XMPP_DOMAIN)
except UserAlreadyRegisteredError:
user2_created = False
# if users already exist delete the second user from the first user's roster
if user1_created == False and user2_created == False:
delete_rosteritem = self.api.delete_rosteritem(
'testuser_15', XMPP_DOMAIN, 'testuser_16', XMPP_DOMAIN)
self.assertTrue(delete_rosteritem)
# check if the first user's roster is empty
roster = self.api.get_roster('testuser_15', XMPP_DOMAIN)
self.assertEqual(roster, [])
# add the second user to the first user's roster
add_rosteritem = self.api.add_rosteritem('testuser_15', XMPP_DOMAIN,
'testuser_16', XMPP_DOMAIN,
'testuser_16', 'buddies',
'both')
self.assertTrue(add_rosteritem)
# check if the first user's roster contains the second user
roster = self.api.get_roster('testuser_15', XMPP_DOMAIN)
self.assertEqual(roster[0]['jid'],
'testuser_16@{0}'.format(XMPP_DOMAIN))
self.assertEqual(roster[0]['group'], 'buddies')
# add the second user to the first user's roster again, now to a different group
add_rosteritem = self.api.add_rosteritem('testuser_15', XMPP_DOMAIN,
'testuser_16', XMPP_DOMAIN,
'testuser_16', 'friends',
'both')
self.assertTrue(add_rosteritem)
# check if the first user's roster contains the second user in the different group
roster = self.api.get_roster('testuser_15', XMPP_DOMAIN)
self.assertEqual(roster[0]['jid'],
'testuser_16@{0}'.format(XMPP_DOMAIN))
self.assertEqual(roster[0]['group'], 'friends')
# delete the second user from the first user's roster
delete_rosteritem = self.api.delete_rosteritem('testuser_15',
XMPP_DOMAIN,
'testuser_16',
XMPP_DOMAIN)
self.assertTrue(delete_rosteritem)
# check if the first user's roster is empty
roster = self.api.get_roster('testuser_15', XMPP_DOMAIN)
self.assertEqual(roster, [])
def test_check_account(self):
with create_test_user(self.api, 'testuser_17',
host=XMPP_DOMAIN) as username:
check_account = self.api.check_account(username, XMPP_DOMAIN)
self.assertTrue(check_account)
self.api.unregister(username, host=XMPP_DOMAIN)
check_account = self.api.check_account(username, XMPP_DOMAIN)
self.assertFalse(check_account)
def test_kick_user(self):
kick_user = self.api.kick_user('admin', XMPP_DOMAIN)
self.assertEqual(kick_user, 0)
def test_kick_session(self):
kick_session = self.api.kick_session('admin', XMPP_DOMAIN, 'foo',
'bar')
self.assertTrue(kick_session)
class EjabberdAPITests(TestCase):
def setUp(self):
verbose = True
self.api = EjabberdAPIClient(host=HOST,
port=PORT,
username=USERNAME,
password=PASSWORD,
user_domain=XMPP_DOMAIN,
protocol=PROTOCOL,
verbose=VERBOSE)
self.assertIsNotNone(self.api)
def test_from_string_ok(self):
service_url = '%s://%s:%s@%s:%s/%s' % (PROTOCOL, USERNAME, PASSWORD,
HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertFalse(error_thrown)
self.assertIsNotNone(api)
def test_from_string_incorrect_protocol(self):
service_url = 'test://%s:%s@%s:%s/%s' % (USERNAME, PASSWORD, HOST,
PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_auth(self):
service_url = '%s://bla@%s:%s/%s' % (PROTOCOL, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_default_server_port(self):
service_url = '%s://%s:%s@%s/%s' % (PROTOCOL, USERNAME, PASSWORD, HOST,
XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertFalse(error_thrown)
self.assertIsNotNone(api)
self.assertEqual(api.port, XMLRPC_API_PORT)
def test_from_string_incorrect_server(self):
service_url = '%s://%s:%s@%s:%s:bla/%s' % (
PROTOCOL, USERNAME, PASSWORD, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_from_string_incorrect_domain(self):
service_url = '%s://%s:%s@%s:%s/%s/bla' % (
PROTOCOL, USERNAME, PASSWORD, HOST, PORT, XMPP_DOMAIN)
api = None
error_thrown = False
try:
api = EjabberdAPIClient.get_instance(service_url)
except AssertionError:
error_thrown = True
self.assertTrue(error_thrown)
self.assertIsNone(api)
def test_echo(self):
sentence = '51@#211323$%^&*()üFße'
result = self.api.echo(sentence)
self.assertIsNotNone(result)
self.assertEqual(result, sentence)
def test_registered_users(self):
result = self.api.registered_users(XMPP_DOMAIN)
self.assertTrue(isinstance(result, (list, tuple)))
registered_users = self.api.registered_users(host=XMPP_DOMAIN)
registered_users = [
struct.get('username') for struct in registered_users
]
self.assertTrue('admin' in registered_users)
def test_register_unregister_user(self):
with create_test_user(self.api, 'testuser_1',
host=XMPP_DOMAIN) as username:
registered_users = self.api.registered_users(host=XMPP_DOMAIN)
registered_users = [
struct.get('username') for struct in registered_users
]
self.assertTrue(username in registered_users)
def test_username_already_exists(self):
with create_test_user(self.api, 'testuser_2',
host=XMPP_DOMAIN) as username:
error_thrown = False
try:
with create_test_user(self.api, 'testuser_2',
host=XMPP_DOMAIN) as username2:
self.assertEqual(username2, username)
except UserAlreadyRegisteredError:
error_thrown = True
self.assertTrue(error_thrown)
def test_change_check_password(self):
with create_test_user(self.api,
'testuser_3',
host=XMPP_DOMAIN,
password='******') as username:
result = self.api.check_password_hash(username,
host=XMPP_DOMAIN,
password='******')
self.assertTrue(result)
result = self.api.check_password_hash(username,
host=XMPP_DOMAIN,
password='******')
self.assertFalse(result)
result = self.api.change_password(username,
host=XMPP_DOMAIN,
newpass='******')
self.assertTrue(result)
result = self.api.check_password_hash(username,
host=XMPP_DOMAIN,
password='******')
self.assertFalse(result)
result = self.api.check_password_hash(username,
host=XMPP_DOMAIN,
password='******')
self.assertTrue(result)
def test_set_nickname(self):
with create_test_user(self.api, 'testuser_4',
host=XMPP_DOMAIN) as username:
result = self.api.set_nickname(username,
host=XMPP_DOMAIN,
nickname='blabla')
self.assertTrue(result)
def test_connected_users(self):
result = self.api.connected_users()
self.assertTrue(isinstance(result, (list)))
def test_connected_users_info(self):
result = self.api.connected_users_info()
self.assertTrue(isinstance(result, (list)))
def test_connected_users_number(self):
result = self.api.connected_users_number()
self.assertTrue(isinstance(result, (int)))
def test_user_sessions_info(self):
result = self.api.user_sessions_info('admin', XMPP_DOMAIN)
self.assertTrue(isinstance(result, (list)))
def test_create_destroy_room(self):
with create_test_room(self.api,
'testroom_1',
service=MUC_SERVICE,
host=XMPP_DOMAIN,
test_existence=False) as room:
online_rooms = self.api.muc_online_rooms()
full_name = '%s@%s' % (room, MUC_SERVICE)
self.assertTrue(full_name in online_rooms)
def test_get_room_options(self):
with create_test_room(self.api,
'testroom_2',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
result = self.api.get_room_options(room, service=MUC_SERVICE)
self.assertTrue(isinstance(result, dict))
def test_room_option_allow_change_subj(self):
with create_test_room(self.api,
'testroom_3',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_change_subj,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_change_subj,
value=True))
def test_room_option_allow_private_messages(self):
with create_test_room(self.api,
'testroom_4',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_private_messages,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_private_messages,
value=True))
def test_room_option_allow_query_users(self):
with create_test_room(self.api,
'testroom_5',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_query_users,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_query_users,
value=True))
def test_room_option_allow_user_invites(self):
with create_test_room(self.api,
'testroom_6',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_user_invites,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_user_invites,
value=True))
def test_room_option_allow_visitor_nickchange(self):
with create_test_room(self.api,
'testroom_7',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_visitor_nickchange,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_visitor_nickchange,
value=True))
def test_room_option_allow_visitor_status(self):
with create_test_room(self.api,
'testroom_8',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_visitor_status,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_visitor_status,
value=True))
def test_room_option_anonymous(self):
with create_test_room(self.api,
'testroom_9',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.anonymous,
value=False))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.anonymous,
value=True))
def test_room_option_captcha_protected(self):
with create_test_room(self.api,
'testroom_10',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.captcha_protected,
value=True))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.captcha_protected,
value=False))
def test_room_option_logging(self):
with create_test_room(self.api,
'testroom_11',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.logging,
value=False))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.logging,
value=True))
def test_room_option_max_users(self):
with create_test_room(self.api,
'testroom_12',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.max_users,
value=10))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.max_users,
value=100))
def test_room_option_members_by_default(self):
with create_test_room(self.api,
'testroom_13',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.members_by_default,
value=False))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.members_by_default,
value=True))
def test_room_option_members_only(self):
with create_test_room(self.api,
'testroom_14',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.members_only,
value=False))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.members_only,
value=True))
def test_room_option_moderated(self):
with create_test_room(self.api,
'testroom_15',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.moderated,
value=True))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.moderated,
value=False))
def test_room_option_password(self):
with create_test_room(self.api,
'testroom_16',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.password,
value='abcdefg'))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.password,
value='51@#211323$%^&*()üFße'))
def test_room_option_password_protected(self):
with create_test_room(self.api,
'testroom_17',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.password_protected,
value=True))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.password_protected,
value=False))
def test_room_option_persistent(self):
with create_test_room(self.api,
'testroom_18',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.persistent,
value=True))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.persistent,
value=False))
def test_room_option_public(self):
with create_test_room(self.api,
'testroom_19',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.public,
value=False))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.public,
value=True))
def test_room_option_public_list(self):
with create_test_room(self.api,
'testroom_20',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.public_list,
value=False))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.public_list,
value=True))
def test_room_option_title(self):
with create_test_room(self.api,
'testroom_21',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.title,
value='51@#211323$%^&*()üFße'))
self.assertTrue(
self.api.change_room_option(room,
service=MUC_SERVICE,
option=MUCRoomOption.title,
value='abcdefg'))
def test_room_option_allow_private_messages_from_visitors(self):
with create_test_room(self.api,
'testroom_22',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_private_messages_from_visitors,
value=AllowVisitorPrivateMessage.nobody))
self.assertTrue(
self.api.change_room_option(
room,
service=MUC_SERVICE,
option=MUCRoomOption.allow_private_messages_from_visitors,
value=AllowVisitorPrivateMessage.moderators))
def test_set_affiliation_outcast(self):
with create_test_user(self.api, 'testuser_5',
host=XMPP_DOMAIN) as username:
with create_test_room(self.api,
'testroom_23',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.outcast))
def test_set_affiliation_none(self):
with create_test_user(self.api, 'testuser_6',
host=XMPP_DOMAIN) as username:
with create_test_room(self.api,
'testroom_24',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.none))
def test_set_affiliation_member(self):
with create_test_user(self.api, 'testuser_7',
host=XMPP_DOMAIN) as username:
with create_test_room(self.api,
'testroom_25',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.member))
def test_set_affiliation_admin(self):
with create_test_user(self.api, 'testuser_8',
host=XMPP_DOMAIN) as username:
with create_test_room(self.api,
'testroom_26',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.admin))
def test_set_affiliation_owner(self):
with create_test_user(self.api, 'testuser_9',
host=XMPP_DOMAIN) as username:
with create_test_room(self.api,
'testroom_28',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
jid = '%s@%s' % (username, XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.owner))
def test_get_affiliations(self):
# Heavy nesting but at least it's compatible with python 2.6
with create_test_user(self.api, 'testuser_10',
host=XMPP_DOMAIN) as username1:
with create_test_user(self.api, 'testuser_11',
host=XMPP_DOMAIN) as username2:
with create_test_user(self.api,
'testuser_12',
host=XMPP_DOMAIN) as username3:
with create_test_user(self.api,
'testuser_13',
host=XMPP_DOMAIN) as username4:
with create_test_user(self.api,
'testuser_14',
host=XMPP_DOMAIN) as username5:
with create_test_room(self.api,
'testroom_29',
service=MUC_SERVICE,
host=XMPP_DOMAIN) as room:
usernames = [
username1, username2, username3, username4,
username5
]
input_affiliations = [
Affiliation.outcast, Affiliation.none,
Affiliation.member, Affiliation.admin,
Affiliation.owner
]
for i in range(len(usernames)):
jid = '%s@%s' % (usernames[i], XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=input_affiliations[i]))
output_affiliations = self.api.get_room_affiliations(
room, service=MUC_SERVICE)
self.assertEqual(len(output_affiliations), 4)
affiliations_dict = {}
for affiliation in output_affiliations:
self.assertEqual(affiliation['domain'],
XMPP_DOMAIN)
self.assertEqual(affiliation['reason'], '')
affiliations_dict[
affiliation['username']] = affiliation[
'affiliation']
for i in range(len(usernames)):
username = usernames[i]
expected_affiliation = input_affiliations[
i]
if expected_affiliation == Affiliation.none:
self.assertTrue(
username not in affiliations_dict)
continue
self.assertEqual(
affiliations_dict[username],
expected_affiliation)
for i in range(len(usernames)):
jid = '%s@%s' % (usernames[i], XMPP_DOMAIN)
self.assertTrue(
self.api.set_room_affiliation(
room,
service=MUC_SERVICE,
jid=jid,
affiliation=Affiliation.none))
output_affiliations = self.api.get_room_affiliations(
room, service=MUC_SERVICE)
self.assertEqual(len(output_affiliations), 0)
