def test_personal_contacts(self):
dao.user.get_context = Mock(return_value=s.profile)
with synchronize(self.async_runner):
self.cti_adapter.personal_contacts(s.token, s.user_id)
self.client.directories.personal.assert_called_once_with(profile=s.profile, token=s.token)
def test_lookup(self):
dao.user.get_context = Mock(return_value=s.profile)
with synchronize(self.async_runner):
self.cti_adapter.search(s.token, s.user_id, s.term)
self.client.directories.lookup.assert_called_once_with(profile=s.profile, term=s.term, token=s.token)
def test_disable_unconditional_fwd(self, client):
with synchronize(self._runner):
self.user_service_manager.disable_unconditional_fwd(SOME_UUID, SOME_TOKEN, s.destination)
client.users(SOME_UUID).update_forward.assert_called_once_with(forward_name='unconditional',
forward={'enabled': False,
'destination': s.destination})
def test_enable_rna_fwd(self, client):
with synchronize(self._runner):
self.user_service_manager.enable_rna_fwd(SOME_UUID, SOME_TOKEN, s.destination)
client.users(SOME_UUID).update_forward.assert_called_once_with(forward_name='noanswer',
forward={'enabled': True,
'destination': s.destination})
def test_hangup_calls_async_hangup(self):
with synchronize(self._runner):
with patch.object(self.manager, '_async_hangup') as async_hangup:
self.manager.hangup(s.connection, s.auth_token, s.user_uuid)
async_hangup.assert_called_once_with(s.connection, self.ctid_ng_client,
s.user_uuid)
def test_personal_contact_raw(self):
source = 'personal'
source_entry_id = '123456789'
with synchronize(self.async_runner):
self.cti_adapter.personal_contact_raw(s.token, s.user_id, source, source_entry_id)
self.client.personal.get.assert_called_once_with(contact_id=source_entry_id, token=s.token)
def test_that_on_result_is_called_with_none_if_no_client(self):
with patch.object(self._fetcher, '_client') as _client_fn:
_client_fn.return_value = None
with patch.object(self._fetcher, '_on_result') as on_result:
with synchronize(self.async_runner):
self._fetcher.fetch(self.key)
on_result.assert_called_once_with(None)
def test_that_fetch_get_from_a_client(self):
with patch.object(self._fetcher, '_client') as _client_fn:
get_status = _client_fn.return_value.endpoints.get
with patch.object(self._fetcher, '_on_result') as on_result:
with synchronize(self.async_runner):
self._fetcher.fetch(self.key)
get_status.assert_called_once_with(self.id_)
on_result.assert_called_once_with(get_status.return_value)
def test_create_personal_contact(self):
contact_infos = {'firstname': 'Bob',
'lastname': 'Le Bricoleur',
'random_key': 'random_value'}
with synchronize(self.async_runner):
self.cti_adapter.create_personal_contact(s.token, s.user_id, contact_infos)
self.client.personal.create.assert_called_once_with(contact_infos=contact_infos, token=s.token)
def test_transfer_complete(self):
transfers = {'items': [{'id': s.transfer_id, 'flow': 'attended'}]}
self.ctid_ng_client.transfers.list_transfers_from_user.return_value = transfers
with synchronize(self._runner):
self.manager.transfer_complete(s.connection, s.auth_token,
s.user_uuid)
self.ctid_ng_client.transfers.complete_transfer_from_user.assert_called_once_with(
s.transfer_id, )
def test_cancel_transfer_no_transfer(self):
transfers = {'items': []}
self.ctid_ng_client.transfers.list_transfers_from_user.return_value = transfers
with synchronize(self._runner):
self.manager.transfer_cancel(s.connection, s.auth_token,
s.user_uuid)
assert_that(
self.ctid_ng_client.transfers.cancel_transfer_from_user.call_count,
equal_to(0))
def test_call_exten_success(self):
call_function = self.ctid_ng_client.calls.make_call_from_user
with patch.object(self.manager, '_on_call_success') as cb:
with synchronize(self._runner):
self.manager.call_exten(s.connection, s.auth_token, s.user_id,
s.exten)
call_function.assert_called_once_with(extension=s.exten)
cb.assert_called_once_with(s.connection, s.user_id,
call_function.return_value)
def test_set_favorite_with_remove_favorite(self):
source = 'internal'
source_entry_id = '123456789'
enabled = False
dao.user.get_context = Mock(return_value=s.profile)
with synchronize(self.async_runner):
self.cti_adapter.set_favorite(s.token, s.user_id, source, source_entry_id, enabled)
self.client.directories.remove_favorite.assert_called_once_with(directory=source,
contact=source_entry_id,
token=s.token)
def test_transfer_blind(self):
with synchronize(self._runner):
with patch.object(self.manager, '_transfer') as transfer:
self.manager.transfer_blind(
s.connection,
s.auth_token,
s.user_id,
s.user_uuid,
s.number,
)
transfer.assert_called_once_with(s.auth_token, s.user_id, s.user_uuid,
s.number, 'blind')
def test_call_exten_exception(self):
call_function = self.ctid_ng_client.calls.make_call_from_user
exception = call_function.side_effect = Exception()
error_handler = Mock(_CallExceptionHandler)
with patch('xivo_cti.services.call.manager._CallExceptionHandler',
Mock(return_value=error_handler)) as ExceptionHandler:
with synchronize(self._runner):
self.manager.call_exten(s.connection, s.auth_token, s.user_id,
s.exten)
ExceptionHandler.assert_called_once_with(s.connection, s.user_id,
s.exten)
call_function.assert_called_once_with(extension=s.exten)
error_handler.handle.assert_called_once_with(exception)
def test_edit_personal_contact(self):
source = 'personal'
source_entry_id = '123456789'
contact_infos = {'firstname': 'Bob',
'lastname': 'Le Bricoleur',
'random_key': 'random_value'}
with synchronize(self.async_runner):
self.cti_adapter.edit_personal_contact(s.token,
s.user_id,
source,
source_entry_id,
contact_infos)
self.client.personal.edit.assert_called_once_with(contact_id=source_entry_id,
contact_infos=contact_infos,
token=s.token)
def test_transfer_blind_to_voicemail(self, mock_dao):
mock_dao.user.get_context.return_value = s.context
with patch.object(self.manager,
'_transfer_to_voicemail') as transfer_to_vm:
with synchronize(self._runner):
self.manager.transfer_blind_to_voicemail(
s.connection,
s.auth_token,
s.user_uuid,
s.voicemail_number,
)
transfer_to_vm.assert_called_once_with(
s.auth_token,
s.user_uuid,
s.voicemail_number,
s.context,
'blind',
)
def test_transfer_attended(self):
with patch.object(self.manager, '_transfer') as transfer:
with synchronize(self._runner):
self.manager.transfer_attended(
s.connection,
s.auth_token,
s.user_id,
s.user_uuid,
s.number,
)
transfer.assert_called_once_with(
s.auth_token,
s.user_id,
s.user_uuid,
s.number,
'attended',
SOME_TRANSFER_TIMEOUT,
)
def test_transfer_blind_to_voicemail_exceptions(self, mock_dao):
mock_dao.user.get_context.return_value = s.context
exception = Exception()
error_handler = Mock(_TransferExceptionHandler)
with patch(
'xivo_cti.services.call.manager._TransferToVoicemailExceptionHandler',
Mock(return_value=error_handler)) as ExceptionHandler:
with patch.object(self.manager, '_transfer_to_voicemail',
Mock(side_effect=exception)):
with synchronize(self._runner):
self.manager.transfer_blind_to_voicemail(
s.connection,
s.auth_token,
s.user_uuid,
s.vm_number,
)
error_handler.handle.assert_called_once_with(exception)
ExceptionHandler.assert_called_once_with(s.connection, s.user_uuid)
def test_transfer_attended_exceptions(self):
exception = Exception()
error_handler = Mock(_TransferExceptionHandler)
with patch('xivo_cti.services.call.manager._TransferExceptionHandler',
Mock(return_value=error_handler)) as ExceptionHandler:
with patch.object(self.manager, '_transfer',
Mock(side_effect=exception)):
with synchronize(self._runner):
self.manager.transfer_attended(
s.connection,
s.auth_token,
s.user_id,
s.user_uuid,
s.number,
)
error_handler.handle.assert_called_once_with(exception)
ExceptionHandler.assert_called_once_with(s.connection, s.user_uuid,
s.number)
def test_directory_search(self, mocked_user_dao):
with synchronize(self.async_runner):
self.cti_adapter.directory_search(s.token, s.user_id, s.term, s.commandid)
self.client.directories.lookup.assert_called_once_with(
profile=mocked_user_dao.get_context.return_value, term=s.term, token=s.token)
def test_lookup(self):
with synchronize(self.async_runner):
self.cti_adapter.lookup(s.token, s.user_id, s.term)
self.client.directories.lookup.assert_called_once_with(profile=self.profile,
term=s.term, token=s.token)
def test_import_personal_contacts_csv(self):
csv_contacts = 'firstname,lastname\r\nBob, the Builder\r\nAlice, Wonderland\r\n'
with synchronize(self.async_runner):
self.cti_adapter.import_personal_contacts_csv(s.token, s.user_id, csv_contacts)
self.client.personal.import_csv.assert_called_once_with(csv_text=csv_contacts, token=s.token)
def test_export_personal_contacts_csv(self):
with synchronize(self.async_runner):
self.cti_adapter.export_personal_contacts_csv(s.token, s.user_id)
self.client.personal.export_csv.assert_called_once_with(token=s.token)
def test_enable_incallfilter(self, client):
with synchronize(self._runner):
self.user_service_manager.enable_filter(SOME_UUID, SOME_TOKEN)
client.users(SOME_UUID).update_service.assert_called_once_with(service_name='incallfilter',
service={'enabled': True})
def test_get_headers(self):
with synchronize(self.async_runner):
self.cti_adapter.get_headers(s.token, s.user_id)
self.client.directories.headers.assert_called_once_with(profile=self.profile, token=s.token)
def test_disable_dnd(self, client):
with synchronize(self._runner):
self.user_service_manager.disable_dnd(SOME_UUID, SOME_TOKEN)
client.users(SOME_UUID).update_service.assert_called_once_with(service_name='dnd',
service={'enabled': False})
