def test_dial_success(self):
expected = {
'class': 'dial_success',
'exten': sentinel.exten,
}
result = CTIMessageFormatter.dial_success(sentinel.exten)
assert_that(result, equal_to(expected))
def test_dial_success(self):
expected = {
'class': 'dial_success',
'exten': s.exten,
}
result = CTIMessageFormatter.dial_success(s.exten)
assert_that(result, equal_to(expected))
def notify(self, phone_id, status):
event = CTIMessageFormatter.phone_hintstatus_update(phone_id, status)
self._ctiserver.send_cti_event(event)
bus_event = EndpointStatusUpdateEvent(config['uuid'], phone_id, status)
self._bus_producer.publish_event(
config['bus']['exchange_name'],
config['bus']['routing_keys']['endpoint_status'],
bus_event,
)
def test_on_originate_success(self):
connection = Mock(CTI)
line = {'protocol': 'SCCP', 'name': 'zzzz'}
self.user_service_manager._on_originate_success(connection, sentinel.exten, line)
self._call_manager.answer_next_ringing_call.assert_called_once_with(connection, 'SCCP/zzzz')
expected_message = CTIMessageFormatter.dial_success(sentinel.exten)
connection.send_message.assert_called_once_with(expected_message)
def test_on_originate_success(self):
connection = Mock(CTI)
line = {'protocol': 'SCCP', 'name': 'zzzz'}
self.user_service_manager._on_originate_success(connection, sentinel.exten, line)
self._call_manager.answer_next_ringing_call.assert_called_once_with(connection, 'SCCP/zzzz')
expected_message = CTIMessageFormatter.dial_success(sentinel.exten)
connection.send_message.assert_called_once_with(expected_message)
def deliver_chat_message(self, from_, to, alias, text):
destination_xivo_uuid, destination_user_uuid = to
if destination_xivo_uuid != self._xivo_uuid:
return
destination_user_id = dao.user.get_by_uuid(destination_user_uuid)['id']
destination = '{}/{}'.format(destination_xivo_uuid, destination_user_id)
msg = CTIMessageFormatter.chat(from_, to, alias, text)
self._cti_server.send_to_cti_client(destination, msg)
def test_error_message(self):
for exception, msg_string in self.exception_msg_map.iteritems():
self.connection.reset_mock()
self.handler.handle(exception)
expected_message = CTIMessageFormatter.ipbxcommand_error(
msg_string)
self.connection.send_message.assert_called_once_with(
expected_message)
def test_report_ipbxcommand_error(self):
msg = 'Ad libitum'
expected = {
'class': 'ipbxcommand',
'error_string': msg,
}
result = CTIMessageFormatter.ipbxcommand_error(msg)
assert_that(result, equal_to(expected), 'Error message')
def test_report_ipbxcommand_error(self):
msg = 'Ad libitum'
expected = {
CLASS: 'ipbxcommand',
'error_string': msg,
}
result = CTIMessageFormatter.ipbxcommand_error(msg)
assert_that(result, equal_to(expected), 'Error message')
def test_login_id(self):
expected = {
'class': 'login_id',
'sessionid': s.session_id,
'wazoversion': xivo_cti.CTI_PROTOCOL_VERSION
}
result = CTIMessageFormatter.login_id(s.session_id)
assert_that(result, equal_to(expected))
def test_people_search_result(self):
search_result = {
'term':
'Bob',
'column_headers': [
'Firstname', 'Lastname', 'Phone number', 'Mobile', 'Fax',
'Email', 'Agent'
],
'column_types': [
None, 'name', 'number_office', 'number_mobile', 'fax', 'email',
'relation_agent'
],
'results': [{
'column_values': [
'Bob', 'Marley', '5555555', '5556666', '5553333',
'*****@*****.**', None
],
'relations': {
'agent': None,
'user': None,
'endpoint': None
},
'source':
'my_ldap_directory'
}, {
'column_values': [
'Charlie', 'Boblin', '5555556', '5554444', '5552222',
'*****@*****.**', None
],
'relations': {
'agent': {
'id': 12,
'xivo_id': 'ad2f36c7-b0f3-48da-a63c-37434fed479b'
},
'user': {
'id': 34,
'xivo_id': 'ad2f36c7-b0f3-48da-a63c-37434fed479b'
},
'endpoint': {
'id': 56,
'xivo_id': 'ad2f36c7-b0f3-48da-a63c-37434fed479b'
},
},
'source':
'internal'
}]
}
result = CTIMessageFormatter.people_search_result(search_result)
expected = dict(search_result)
expected.update({'class': 'people_search_result'})
assert_that(result, equal_to(expected))
def test_people_search_result(self):
search_result = {
"term":
"Bob",
"column_headers": [
"Firstname", "Lastname", "Phone number", "Mobile", "Fax",
"Email", "Agent"
],
"column_types": [
None, "name", "number_office", "number_mobile", "fax", "email",
"relation_agent"
],
"results": [{
"column_values": [
"Bob", "Marley", "5555555", "5556666", "5553333",
"*****@*****.**", None
],
"relations": {
"agent": None,
"user": None,
"endpoint": None
},
"source":
"my_ldap_directory"
}, {
"column_values": [
"Charlie", "Boblin", "5555556", "5554444", "5552222",
"*****@*****.**", None
],
"relations": {
"agent": {
"id": 12,
"xivo_id": "ad2f36c7-b0f3-48da-a63c-37434fed479b"
},
"user": {
"id": 34,
"xivo_id": "ad2f36c7-b0f3-48da-a63c-37434fed479b"
},
"endpoint": {
"id": 56,
"xivo_id": "ad2f36c7-b0f3-48da-a63c-37434fed479b"
},
},
"source":
"internal"
}]
}
result = CTIMessageFormatter.people_search_result(search_result)
expected = dict(search_result)
expected.update({'class': 'people_search_result'})
assert_that(result, equal_to(expected))
def test_people_headers_result(self):
headers = {'column_headers': s.headers, 'column_types': s.types}
expected = {
'class': 'people_headers_result',
'column_headers': s.headers,
'column_types': s.types
}
result = CTIMessageFormatter.people_headers_result(headers)
assert_that(result, equal_to(expected))
def test_people_export_personal_contacts_csv_result(self):
result = 'firstname,lastname\r\nBob,the Buidler\r\n,Alice,Wonderland\r\n'
expected = {
'class': 'people_export_personal_contacts_csv_result',
'csv_contacts': result
}
result = CTIMessageFormatter.people_export_personal_contacts_csv_result(
result)
assert_that(result, equal_to(expected))
def notify(self, phone_id, status):
cti_event = CTIMessageFormatter.phone_hintstatus_update(
phone_id, status)
self._ctiserver.send_cti_event(cti_event)
bus_event = EndpointStatusUpdateEvent(phone_id, status)
user_id = self._innerdata.xod_config['phones'].keeplist[phone_id][
'iduserfeatures']
user_uuid = self._innerdata.xod_config['users'].keeplist[str(
user_id)]['uuid']
headers = {'user_uuid:{uuid}'.format(uuid=user_uuid): True}
self._bus_publisher.publish(bus_event, headers=headers)
def get_relations(self, user_id):
logger.debug('User %s is requesting his relations', user_id)
xuserid = 'xivo/{user_id}'.format(user_id=user_id)
try:
line_id = dao.user.get_line(user_id)['id']
except NoSuchLineException:
line_id = None
agent_id = dao.user.get_agent_id(user_id)
msg = CTIMessageFormatter.relations(self._uuid, user_id, line_id, agent_id)
self._cti_server.send_to_cti_client(xuserid, msg)
def test_delete_queue_members(self):
queue_member_ids = xrange(1, 4)
expected = {
'class': 'getlist',
'listname': 'queuemembers',
'function': 'delconfig',
'tipbxid': 'xivo',
'list': [1, 2, 3],
}
result = CTIMessageFormatter.delete_queue_members(queue_member_ids)
self.assertEqual(result, expected)
def test_people_personal_contact_raw_update(self):
source = 'personal'
source_entry_id = '123456789'
expected = {
'class': 'people_personal_contact_raw_update',
'source': source,
'source_entry_id': source_entry_id,
}
result = CTIMessageFormatter.people_personal_contact_raw_update(
source, source_entry_id)
assert_that(result, equal_to(expected))
def test_delete_queue_members(self):
queue_member_ids = xrange(1, 4)
expected = {
'class': 'getlist',
'listname': 'queuemembers',
'function': 'delconfig',
'tipbxid': 'xivo',
'list': [1, 2, 3],
}
result = CTIMessageFormatter.delete_queue_members(queue_member_ids)
self.assertEqual(result, expected)
def test_update_agent_status(self):
agent_id = 42
agent_status = {'availability': AgentStatus.logged_out,
'availability_since': 123456789}
expected_result = {'class': 'getlist',
'listname': 'agents',
'function': 'updatestatus',
'tipbxid': 'xivo',
'tid': agent_id,
'status': agent_status}
result = CTIMessageFormatter.update_agent_status(agent_id, agent_status)
self.assertEqual(result, expected_result)
def test_people_headers_result(self):
headers = {
'column_headers': sentinel.headers,
'column_types': sentinel.types
}
expected = {
'class': 'people_headers_result',
'column_headers': sentinel.headers,
'column_types': sentinel.types
}
result = CTIMessageFormatter.people_headers_result(headers)
assert_that(result, equal_to(expected))
def test_update_queue_member_config(self):
queue_member = Mock(QueueMember, id=12)
queue_member.to_cti_config.return_value = s.config
expected = {
'class': 'getlist',
'listname': 'queuemembers',
'function': 'updateconfig',
'tipbxid': 'xivo',
'tid': 12,
'config': s.config,
}
result = CTIMessageFormatter.update_queue_member_config(queue_member)
self.assertEqual(result, expected)
def test_user_status_update(self):
result = CTIMessageFormatter.user_status_update(
s.xivo_uuid, s.user_uuid, s.user_id, s.status)
assert_that(
result,
equal_to({
'class': 'user_status_update',
'data': {
'xivo_uuid': s.xivo_uuid,
'user_uuid': s.user_uuid,
'user_id': s.user_id,
'status': s.status,
}
}))
def test_update_queue_member_config(self):
queue_member = Mock(QueueMember, id=12)
queue_member.to_cti_config.return_value = sentinel.config
expected = {
'class': 'getlist',
'listname': 'queuemembers',
'function': 'updateconfig',
'tipbxid': 'xivo',
'tid': 12,
'config': sentinel.config,
}
result = CTIMessageFormatter.update_queue_member_config(queue_member)
self.assertEqual(result, expected)
def test_endpoint_status_update(self):
key = ('xivo-uuid', 42)
status = 0
result = CTIMessageFormatter.endpoint_status_update(key, status)
assert_that(
result,
equal_to({
'class': 'endpoint_status_update',
'data': {
'xivo_uuid': 'xivo-uuid',
'endpoint_id': 42,
'status': 0,
}
}))
def test_agent_status_update(self):
key = ('xivo-uuid', 42)
status = 'logged_out'
result = CTIMessageFormatter.agent_status_update(key, status)
assert_that(
result,
equal_to({
'class': 'agent_status_update',
'data': {
'xivo_uuid': 'xivo-uuid',
'agent_id': 42,
'status': 'logged_out',
}
}))
def test_getlist_update_status_user(self):
result = CTIMessageFormatter.getlist_update_status_users(
s.user_id, s.status)
assert_that(
result,
equal_to({
'class': 'getlist',
'function': 'updatestatus',
'listname': 'users',
'tipbxid': 'xivo',
'tid': s.user_id,
'status': {
'availstate': s.status
}
}))
def test_relations_no_endpoint_no_agent(self):
xivo_uuid = 'my-xivo-uuid'
user_id = '42'
result = CTIMessageFormatter.relations(xivo_uuid, user_id, None, None)
assert_that(
result,
equal_to({
'class': 'relations',
'data': {
'xivo_uuid': xivo_uuid,
'user_id': 42,
'endpoint_id': None,
'agent_id': None
}
}))
def test_people_favorite_update(self):
source = 'internal'
source_entry_id = '123456789'
enabled = True
set_favorite_result = {
'class': 'people_favorite_update',
'source': source,
'source_entry_id': source_entry_id,
'favorite': enabled
}
result = CTIMessageFormatter.people_favorite_update(
source, source_entry_id, enabled)
expected = dict(set_favorite_result)
expected.update({'class': 'people_favorite_update'})
assert_that(result, equal_to(expected))
def test_update_phone_hinstatus(self):
hint = 8
phone_id = '42'
result = CTIMessageFormatter.phone_hintstatus_update(phone_id, hint)
assert_that(
result,
equal_to({
'class': 'getlist',
'listname': 'phones',
'function': 'updatestatus',
'tipbxid': 'xivo',
'tid': phone_id,
'status': {
'hintstatus': hint
}
}))
def test_people_personal_contact_raw_result(self):
source = 'personal'
source_entry_id = '123456789'
contact_infos = {'firstname': 'Bob', 'lastname': 'The Builder'}
expected = {
'class': 'people_personal_contact_raw_result',
'source': source,
'source_entry_id': source_entry_id,
'contact_infos': {
'firstname': 'Bob',
'lastname': 'The Builder'
}
}
result = CTIMessageFormatter.people_personal_contact_raw_result(
source, source_entry_id, contact_infos)
assert_that(result, equal_to(expected))
def test_people_personal_contacts_result(self):
personal_contacts_result = {
'column_headers': [
'Firstname', 'Lastname', 'Phone number', 'Mobile', 'Fax',
'Email', 'Agent', 'Favorite', 'Personal'
],
'column_types': [
None, 'name', 'number_office', 'number_mobile', 'fax', 'email',
'relation_agent', 'favorite', 'personal'
],
'results': [{
'column_values': [
'Bob', 'Marley', '5555555', '5556666', '5553333',
'*****@*****.**', None, True, True
],
'relations': {
'agent': None,
'user': None,
'endpoint': None
},
'source':
'personal'
}, {
'column_values': [
'Charlie', 'Boblin', '5555556', '5554444', '5552222',
'*****@*****.**', None, False, True
],
'relations': {
'agent': None,
'user': None,
'endpoint': None
},
'source':
'personal'
}]
}
result = CTIMessageFormatter.people_personal_contacts_result(
personal_contacts_result)
expected = dict(personal_contacts_result)
expected.update({'class': 'people_personal_contacts_result'})
assert_that(result, equal_to(expected))
def test_update_agent_status(self):
agent_id = 42
agent_status = {
'availability': AgentStatus.logged_out,
'availability_since': 123456789
}
expected_result = {
'class': 'getlist',
'listname': 'agents',
'function': 'updatestatus',
'tipbxid': 'xivo',
'tid': agent_id,
'status': agent_status
}
result = CTIMessageFormatter.update_agent_status(
agent_id, agent_status)
self.assertEqual(result, expected_result)
def test_relations(self):
xivo_uuid = 'my-xivo-uuid'
user_id = '42'
endpoint_id = '50'
agent_id = '24'
result = CTIMessageFormatter.relations(xivo_uuid, user_id, endpoint_id,
agent_id)
assert_that(
result,
equal_to({
'class': 'relations',
'data': {
'xivo_uuid': xivo_uuid,
'user_id': 42,
'endpoint_id': 50,
'agent_id': 24
}
}))
def test_people_search_result(self):
search_result = {
"term": "Bob",
"column_headers": ["Firstname", "Lastname", "Phone number", "Mobile", "Fax", "Email", "Agent"],
"column_types": [None, "name", "number_office", "number_mobile", "fax", "email", "relation_agent"],
"results": [
{
"column_values": ["Bob", "Marley", "5555555", "5556666", "5553333", "*****@*****.**", None],
"relations": {
"agent": None,
"user": None,
"endpoint": None
},
"source": "my_ldap_directory"
}, {
"column_values": ["Charlie", "Boblin", "5555556", "5554444", "5552222", "*****@*****.**", None],
"relations": {
"agent": {
"id": 12,
"xivo_id": "ad2f36c7-b0f3-48da-a63c-37434fed479b"
},
"user": {
"id": 34,
"xivo_id": "ad2f36c7-b0f3-48da-a63c-37434fed479b"
},
"endpoint": {
"id": 56,
"xivo_id": "ad2f36c7-b0f3-48da-a63c-37434fed479b"
},
},
"source": "internal"
}
]
}
result = CTIMessageFormatter.people_search_result(search_result)
expected = dict(search_result)
expected.update({'class': 'people_search_result'})
assert_that(result, equal_to(expected))
def _on_login_id(self, userlogin, xivo_version, cti_connection):
if cti_connection != self._connection:
return
LoginID.deregister_callback(self._on_login_id)
if xivo_version != xivo_cti.CTI_PROTOCOL_VERSION:
logger.info(
'%s failed to connect: the client protocol version %s is different from the server protocol version %s',
userlogin, xivo_version, xivo_cti.CTI_PROTOCOL_VERSION)
msg = 'wazoversion_client:{};{}'.format(
xivo_version, xivo_cti.CTI_PROTOCOL_VERSION)
self._fatal('login_id', msg)
return
self._username = userlogin
LoginPass.register_callback_params(self._on_login_pass,
['password', 'cti_connection'])
msg = CTIMessageFormatter.login_id(self._session_id)
self._send_msg(msg)
def _on_auth_success(self, token_data):
if not token_data:
return
self._user_uuid = token_data['xivo_user_uuid']
try:
user_config = dao.user.get_by_uuid(self._user_uuid)
except NoSuchUserException:
return self._fatal('login_pass', 'user_not_found')
self._cti_profile_id = user_config.get('cti_profile_id')
if not self._cti_profile_id:
logger.info('%s failed to login, profile %s', self._username,
self._cti_profile_id)
return self._fatal('login_pass', 'login_password')
self._authenticated = True
self._auth_token = token_data['token']
self._user_id = str(user_config['id'])
msg = CTIMessageFormatter.login_pass(self._cti_profile_id)
LoginCapas.register_callback_params(
self._on_login_capas, ['capaid', 'state', 'cti_connection'])
self._send_msg(msg)
self._on_auth_complete()
def test_people_import_personal_contacts_csv_result(self):
result = {
'failed': [{
'line': 3,
'errors': ['missing fields']
}],
'created': [{
'firstname': 'Toto',
'lastname': 'Bélanger'
}, {
'firstname': 'Tata',
'lastanem': 'Bergeron'
}]
}
expected = {
'class': 'people_import_personal_contacts_csv_result',
'failed': result['failed'],
'created_count': len(result['created'])
}
result = CTIMessageFormatter.people_import_personal_contacts_csv_result(
result)
assert_that(result, equal_to(expected))
def _send_headers_result(self, user_id, headers):
xuserid = 'xivo/{user_id}'.format(user_id=user_id)
message = CTIMessageFormatter.people_headers_result(headers)
self._cti_server.send_to_cti_client(xuserid, message)
def notify(self, agent_id):
agent_status = dao.agent.agent_status(agent_id)
cti_message = CTIMessageFormatter.update_agent_status(agent_id, agent_status)
self.cti_server.send_cti_event(cti_message)
def _send_lookup_result(self, user_id, result):
xuserid = 'xivo/{user_id}'.format(user_id=user_id)
message = CTIMessageFormatter.people_search_result(result)
self._cti_server.send_to_cti_client(xuserid, message)