def test_unregister_without_callbak(self):
mock = Mock()
register(event='event_name', callback=mock)
self.assertEqual(queue_size('event_name'), 1)
unregister(event='event_name')
self.assertEqual(queue_size('event_name'), 0)
trigger('event_name', 'custom data')
mock.assert_not_called()
def test_unregister_with_unique_id(self):
mock = Mock()
register(event='event_name', callback=mock, suffix='xxx')
self.assertEqual(queue_size('event_name', 'xxx'), 1)
unregister(event='event_name', callback=mock, suffix='xxx')
self.assertEqual(queue_size('event_name', 'xxx'), 0)
trigger('event_name', 'custom data', 'xxx')
mock.assert_not_called()
def test_trigger_with_unique_id(self):
mock1 = Mock()
register(event='event_name', callback=mock1, suffix='some_uuid')
mock2 = Mock()
register(event='event_name', callback=mock2, suffix='other_uuid')
mock1.assert_not_called()
mock2.assert_not_called()
trigger('event_name', 'custom data', suffix='some_uuid')
mock1.assert_called_once()
mock2.assert_not_called()
def notification_handler(self, notification):
notification['params']['event_type'] = notification['event_type']
message = Message(notification['params'])
if notification['event_type'] == Notification.STATE:
trigger(self.client.protocol,
message,
suffix=self.ctx_state_unique(message.context))
elif notification['event_type'] == Notification.RECEIVE:
trigger(self.client.protocol,
message,
suffix=self.ctx_receive_unique(message.context))
def _on_detect(self, params):
call = self._get_call_by_id(params['call_id'])
if call is not None:
trigger(Notification.DETECT, params, suffix=params['control_id']
) # Notify components listening on Detect and control_id
try:
event = params['detect']['params']['event']
suffix = event if event == DetectState.FINISHED or event == DetectState.ERROR else 'update'
trigger(call.tag, params['detect'], suffix=f"detect.{suffix}")
except KeyError:
pass
async def _connect(self):
try:
await self.connection.connect()
asyncio.create_task(self.on_socket_open())
await self.connection.read()
self.on_socket_close()
except aiohttp.client_exceptions.ClientConnectorError as error:
trigger(WebSocketEvents.ERROR, error, suffix=self.uuid)
logging.warn(f"{self.host} seems down..")
try:
logging.info('Connection closed..')
await asyncio.sleep(5)
except asyncio.CancelledError:
pass
def message_handler(self, msg):
trigger(WebSocketEvents.MESSAGE, msg, suffix=self.uuid)
if msg.id not in self._requests:
return handle_inbound_message(self, msg)
if hasattr(msg, 'error'):
self._set_exception(msg.id, msg.error)
elif hasattr(msg, 'result'):
try:
if msg.result['result']['code'] == '200':
self._set_result(msg.id, msg.result)
else:
self._set_exception(msg.id, msg.result['result'])
except KeyError: # not a Relay with "result.result.code"
self._set_result(msg.id, msg.result)
async def on_socket_open(self):
try:
self._idle = False
trigger(WebSocketEvents.OPEN, suffix=self.uuid)
result = await self.execute(
Connect(project=self.project, token=self.token))
self.session_id = result['sessionid']
self.signature = result['authorization']['signature']
self.protocol = await setup_protocol(self)
await self._clearExecuteQueue()
self._pong = True
self.keepalive()
logging.info('Client connected!')
trigger(Constants.READY, self, suffix=self.uuid)
except Exception as error:
logging.error('Client setup error: {0}'.format(str(error)))
await self.connection.close()
def _on_state(self, params):
call = self._get_call_by_id(params['call_id'])
tag = params.get('tag', None)
if call is None and tag is not None:
call = self._get_call_by_tag(tag)
if call is not None:
if call.id is None:
call.id = params['call_id']
call.node_id = params['node_id']
trigger(Notification.STATE, params, suffix=call.tag
) # Notify components listening on State and Tag
call._state_changed(params)
elif 'call_id' in params and 'peer' in params:
call = Call(calling=self, **params)
else:
logging.error('Unknown call {0}'.format(params['call_id']))
def _on_record(self, params):
call = self._get_call_by_id(params['call_id'])
if call is not None:
trigger(Notification.RECORD, params, suffix=params['control_id']
) # Notify components listening on Record and control_id
trigger(call.tag, params, suffix='record.stateChange')
trigger(call.tag, params, suffix=f"record.{params['state']}")
def _on_tap(self, params):
call = self._get_call_by_id(params['call_id'])
if call is not None:
trigger(Notification.TAP, params, suffix=params['control_id']
) # Notify components listening on Tap and control_id
trigger(call.tag, params, suffix='tap.stateChange')
trigger(call.tag, params, suffix=f"tap.{params['state']}")
def _on_play(self, params):
call = self._get_call_by_id(params['call_id'])
if call is not None:
trigger(Notification.PLAY, params, suffix=params['control_id']
) # Notify components listening on Play and control_id
trigger(call.tag, params, suffix='play.stateChange')
trigger(call.tag, params, suffix=f"play.{params['state']}")
def _on_send_digits(self, params):
call = self._get_call_by_id(params['call_id'])
if call is not None:
trigger(
Notification.SEND_DIGITS, params, suffix=params['control_id']
) # Notify components listening on SendDigits and control_id
trigger(call.tag, params, suffix='sendDigits.stateChange')
trigger(call.tag, params, suffix=f"sendDigits.{params['state']}")
def test_register_once_with_unique_id(self):
mock = Mock()
register_once(event='event_name', callback=mock, suffix='uuid')
self.assertEqual(queue_size('event_name', 'uuid'), 1)
trigger('event_name', 'custom data', suffix='uuid')
self.assertEqual(queue_size('event_name'), 0)
trigger('event_name', 'custom data', suffix='uuid')
trigger('event_name', 'custom data', suffix='uuid')
mock.assert_called_once()
def test_register_once(self):
mock = Mock()
register_once(event='event_name', callback=mock)
self.assertEqual(queue_size('event_name'), 1)
trigger('event_name', 'custom data')
self.assertEqual(queue_size('event_name'), 0)
trigger('event_name', 'custom data')
trigger('event_name', 'custom data')
mock.assert_called_once()
def test_unregister_all(self):
mock = Mock()
register(event='event_name', callback=mock)
register(event='event_name', callback=mock, suffix='t1')
register(event='event_name', callback=mock, suffix='t2')
unregister_all('event_name')
trigger('event_name', 'custom data')
trigger('event_name', 'custom data', suffix='t1')
trigger('event_name', 'custom data', suffix='t2')
mock.assert_not_called()
def _on_fax(self, params):
call = self._get_call_by_id(params['call_id'])
if call is not None:
trigger(Notification.FAX, params, suffix=params['control_id']
) # Notify components listening on Fax and control_id
trigger(call.tag, params, suffix='fax.stateChange')
try:
trigger(call.tag,
params,
suffix=f"fax.{params['fax']['type']}")
except KeyError:
pass
def _state_changed(self, params):
self.prev_state = self.state
self.state = params['call_state']
trigger(self.tag, params, suffix='stateChange')
trigger(self.tag, params, suffix=self.state)
if self.state == CallState.ENDED:
check_id = self.id if self.id else self.tag
trigger(check_id, params,
suffix=CallState.ENDED) # terminate components
unregister_all(self.tag) # unregister all external handlers
end_reason = params.get('end_reason', '')
self.failed = end_reason == DisconnectReason.ERROR
self.busy = end_reason == DisconnectReason.BUSY
self.calling.remove_call(self)
def _on_connect(self, params):
call = self._get_call_by_id(params['call_id'])
state = params['connect_state']
if call is not None:
try:
if state == ConnectState.CONNECTED:
call.peer = self._get_call_by_id(params['peer']['call_id'])
else:
call.peer = None
except KeyError:
pass
trigger(Notification.CONNECT, params, suffix=call.tag
) # Notify components listening on Connect and Tag
trigger(call.tag, params, suffix='connect.stateChange')
trigger(call.tag, params, suffix=f"connect.{state}")
def notification_handler(self, notification):
context = notification['context']
logging.info(f'Receive task in context: {context}')
trigger(self.client.protocol, notification['message'], suffix=self.ctx_receive_unique(context))
def on_socket_close(self):
if self._pingInterval:
self._pingInterval.cancel()
self.contexts = []
trigger(WebSocketEvents.CLOSE, suffix=self.uuid)
def test_trigger(self):
mock = Mock()
register(event='event_name', callback=mock)
mock.assert_not_called()
trigger('event_name', 'custom data')
mock.assert_called_once()
def _on_receive(self, params):
call = Call(calling=self, **params)
trigger(self.client.protocol,
call,
suffix=self.ctx_receive_unique(call.context))
def _on_collect(self, params):
call = self._get_call_by_id(params['call_id'])
if call is not None:
trigger(Notification.COLLECT, params, suffix=params['control_id']
) # Notify components listening on Collect and control_id
trigger(call.tag, params, suffix='prompt')
