def given_answered_user_relocate(self):
user_uuid = SOME_USER_UUID
relocated_channel_id, initiator_channel_id = self.given_bridged_call_stasis(
callee_uuid=user_uuid)
line_id = SOME_LINE_ID
token = self.given_user_token(user_uuid)
self.confd.set_users(MockUser(uuid=user_uuid, line_ids=[line_id]))
self.confd.set_lines(
MockLine(id=line_id,
name='recipient_autoanswer@local',
protocol='local',
context=SOME_CONTEXT))
calld = self.make_calld(token)
destination = 'line'
location = {'line_id': line_id}
completions = ['api']
relocate = calld.relocates.create_from_user(initiator_channel_id,
destination, location,
completions)
def all_talking():
assert_that(relocate['relocated_call'], self.c.is_talking(),
'relocated channel not talking')
assert_that(relocate['initiator_call'], self.c.is_talking(),
'initiator channel not talking')
assert_that(relocate['recipient_call'], self.c.is_talking(),
'recipient channel not talking')
until.assert_(all_talking, timeout=5)
return relocate, user_uuid
def given_completed_user_relocate(self):
user_uuid = SOME_USER_UUID
relocated_channel_id, initiator_channel_id = self.given_bridged_call_stasis(
callee_uuid=user_uuid)
line_id = SOME_LINE_ID
token = self.given_user_token(user_uuid)
self.confd.set_users(MockUser(uuid=user_uuid, line_ids=[line_id]))
self.confd.set_lines(
MockLine(id=line_id,
name='recipient_autoanswer@local',
protocol='local',
context=SOME_CONTEXT))
calld = self.make_calld(token)
destination = 'line'
location = {'line_id': line_id}
relocate = calld.relocates.create_from_user(initiator_channel_id,
destination, location)
until.assert_(
self.assert_relocate_is_completed,
relocate['uuid'],
relocate['relocated_call'],
relocate['initiator_call'],
relocate['recipient_call'],
timeout=5,
)
return relocate, user_uuid
def test_given_http_user_subscription_to_localhost_when_bus_event_then_callback_not_called(
self, control_subscription, sentinel_subscription):
# sentinel should not be triggered
self.bus.publish(
trigger_event(),
routing_key=SOME_ROUTING_KEY,
headers={
'name': TRIGGER_EVENT_NAME,
'user_uuid:{uuid}'.format(uuid=ALICE_USER_UUID): True,
},
)
# trigger control webhook
self.bus.publish(
event(name=ANOTHER_TRIGGER_EVENT_NAME),
routing_key=SOME_ROUTING_KEY,
headers={
'name': ANOTHER_TRIGGER_EVENT_NAME,
'user_uuid:{uuid}'.format(uuid=ALICE_USER_UUID): True,
},
)
until.assert_(
self.make_third_party_verify_callback(request={
'method': 'GET',
'path': '/test'
},
count=1,
exact=True),
timeout=10,
interval=0.5,
)
assert_that(self.sentinel.called(), is_(False))
def given_waiting_relocated_user_relocate(self):
user_uuid = str(uuid.uuid4())
relocated_channel_id, initiator_channel_id = self.given_bridged_call_not_stasis(
callee_uuid=user_uuid,
caller_variables={'WAIT_BEFORE_STASIS': '60'})
line_id = SOME_LINE_ID
token = self.given_user_token(user_uuid)
self.confd.set_users(MockUser(uuid=user_uuid, line_ids=[line_id]))
self.confd.set_lines(
MockLine(id=line_id,
name='recipient_autoanswer@local',
protocol='local',
context=SOME_CONTEXT))
calld = self.make_calld(token)
destination = 'line'
location = {'line_id': line_id}
relocate = calld.relocates.create_from_user(initiator_channel_id,
destination, location)
def relocate_waiting_relocated():
assert_that(relocated_channel_id, self.c.is_talking(),
'relocated channel not talking')
assert_that(initiator_channel_id, self.c.is_hungup(),
'initiator channel is still talking')
assert_that(relocate['recipient_call'], self.c.is_talking(),
'recipient channel not talking')
until.assert_(relocate_waiting_relocated, timeout=5)
return relocate, user_uuid
def test_register_error_then_no_user_created(self):
args = {
'username': '******',
'lastname': 'Denver',
'email_address': '*****@*****.**',
'password': '******',
}
self.stop_service('smtp')
assert_that(
calling(self.client.users.register).with_args(**args),
raises(requests.HTTPError),
)
self.start_service('smtp')
def user_registered():
try:
user = self.client.users.register(**args)
except Exception as e:
self.fail(e)
assert_that(user, has_entries(username='******'))
self.client.users.delete(user['uuid'])
until.assert_(user_registered, timeout=3.0)
def test_given_http_subscription_with_content_type_when_bus_event_then_http_callback_with_content_type(
self, subscription):
self.bus.publish(
trigger_event(),
routing_key=SOME_ROUTING_KEY,
headers={'name': TRIGGER_EVENT_NAME},
)
until.assert_(
self.make_third_party_verify_callback(
request={
'method':
'POST',
'path':
'/test',
'body':
'keỳ: vàlue',
'headers': [{
'name': 'Content-Type',
'values': ['text/yaml; charset=utf-8']
}],
}),
timeout=10,
interval=0.5,
)
def test_given_one_http_subscription_when_restart_rabbitmq_then_callback_still_triggered(
self, subscription):
self.restart_service('rabbitmq')
ConnectedWaitStrategy().wait(self.make_webhookd(MASTER_TOKEN))
# FIXME(sileht): BusClient should reconnect automatically
self.bus = self.make_bus()
until.true(self.bus.is_up,
timeout=5,
message='rabbitmq did not come back up')
self.bus.publish(
trigger_event(),
routing_key=SOME_ROUTING_KEY,
headers={'name': TRIGGER_EVENT_NAME},
)
until.assert_(
self.make_third_party_verify_callback(request={
'method': 'GET',
'path': '/test'
}),
timeout=10,
interval=0.5,
)
def _assert_chat_msg_sent_on_bus(self, message):
def assert_function():
assert_that(
self.events.accumulate(),
has_items(
{
'name':
'chat_message_event',
'origin_uuid':
XIVO_UUID,
'required_acl':
'events.chat.message.{}.{}'.format(
XIVO_UUID, message.to),
'data': {
'alias': message.alias,
'to': [XIVO_UUID, message.to],
'from': [XIVO_UUID, self.token_user_uuid],
'msg': message.content,
}
},
has_entry('name', 'chat_message_received'),
has_entry('name', 'chat_message_sent'),
))
until.assert_(assert_function, tries=5)
def test_given_one_http_subscription_when_update_events_then_callback_triggered_on_the_right_event(
self, subscription):
webhookd = self.make_webhookd(MASTER_TOKEN)
old_trigger_name = TRIGGER_EVENT_NAME
subscription['events'] = [ANOTHER_TRIGGER_EVENT_NAME]
webhookd.subscriptions.update(subscription['uuid'], subscription)
self.ensure_webhookd_consume_uuid(subscription['uuid'])
self.bus.publish(
event(name=old_trigger_name),
routing_key=SOME_ROUTING_KEY,
headers={'name': old_trigger_name},
)
self.bus.publish(
event(name=ANOTHER_TRIGGER_EVENT_NAME),
routing_key=SOME_ROUTING_KEY,
headers={'name': ANOTHER_TRIGGER_EVENT_NAME},
)
until.assert_(
self.make_third_party_verify_callback(request={
'method': 'GET',
'path': '/test'
},
count=1,
exact=True),
timeout=10,
interval=0.5,
)
def test_given_two_http_subscriptions_when_update_config_then_callback_triggered_with_new_config(
self, subscription, _):
webhookd = self.make_webhookd(MASTER_TOKEN)
subscription['config']['url'] = 'http://third-party-http:1080/new-url'
webhookd.subscriptions.update(subscription['uuid'], subscription)
self.ensure_webhookd_consume_uuid(subscription['uuid'])
self.bus.publish(
trigger_event(),
routing_key=SOME_ROUTING_KEY,
headers={'name': TRIGGER_EVENT_NAME},
)
until.assert_(
self.make_third_party_verify_callback(request={
'method': 'GET',
'path': '/new-url'
}),
timeout=10,
interval=0.5,
)
until.assert_(
self.make_third_party_verify_callback(request={
'method': 'GET',
'path': '/test'
},
count=1,
exact=True),
timeout=10,
interval=0.5,
)
def test_given_one_http_subscription_when_bus_event_then_one_http_callback(
self, subscription):
self.bus.publish(
trigger_event(),
routing_key=SOME_ROUTING_KEY,
headers={'name': TRIGGER_EVENT_NAME},
)
until.assert_(
self.make_third_party_verify_callback(request={
'method': 'GET',
'path': '/test'
},
count=1,
exact=True),
timeout=10,
interval=0.5,
)
webhookd = self.make_webhookd(MASTER_TOKEN)
logs = webhookd.subscriptions.get_logs(subscription["uuid"])
assert_that(logs['total'], equal_to(1))
assert_that(logs['items'],
contains(has_entries(status="success", attempts=1)))
def setUp(self):
super().setUp()
self.tenant_uuid = SUB_TENANT
self.tenant_name = 'mytenant'
bus_port = self.service_port(5672, 'rabbitmq')
bus = BusClient.from_connection_fields(host='localhost', port=bus_port)
until.true(bus.is_up, timeout=5)
bus_url = 'amqp://{username}:{password}@{host}:{port}//'.format(
username='******',
password='******',
host='localhost',
port=bus_port)
connection = kombu.Connection(bus_url)
connection.connect()
marshaler = Marshaler('the-xivo-uuid')
exchange = kombu.Exchange('xivo', type='topic')
producer = kombu.Producer(connection,
exchange=exchange,
auto_declare=True)
self.publisher = Publisher(producer, marshaler)
self.mock_auth_client = MockAuthClient('localhost',
self.service_port(9497, 'auth'))
def wait_for_dird_bus_connection():
response = self.client.status.get()
assert_that(response, has_entries(bus_consumer={'status': 'ok'}))
until.assert_(wait_for_dird_bus_connection, timeout=6)
def test_refresh_token_created_event(self, user):
routing_key = 'auth.users.{uuid}.tokens.*.created'.format(**user)
msg_accumulator = self.new_message_accumulator(routing_key)
client_id = 'mytestapp'
self._post_token(
'foo',
'bar',
session_type='Mobile',
access_type='offline',
client_id=client_id,
)
def bus_received_msg():
assert_that(
msg_accumulator.accumulate(),
contains(
has_entries(
data={
'client_id': client_id,
'user_uuid': user['uuid'],
'tenant_uuid': user['tenant_uuid'],
'mobile': True,
})),
)
until.assert_(bus_received_msg, tries=10, interval=0.25)
def test_given_stasis_channels_a_b_when_b_relocate_to_mobile_and_answer_then_a_talks_with_mobile(
self):
user_uuid = SOME_USER_UUID
line_id = 12
self.confd.set_users(
MockUser(uuid=user_uuid,
line_ids=[line_id],
mobile='recipient_autoanswer'))
self.confd.set_lines(MockLine(id=line_id, context='local'))
token = self.given_user_token(user_uuid)
relocated_channel_id, initiator_channel_id = self.given_bridged_call_stasis(
callee_uuid=user_uuid)
calld = self.make_calld(token)
relocate = calld.relocates.create_from_user(initiator_channel_id,
'mobile')
until.assert_(
self.assert_relocate_is_completed,
relocate['uuid'],
relocated_channel_id,
initiator_channel_id,
relocate['recipient_call'],
timeout=5,
)
def test_given_one_http_subscription_with_no_body_when_bus_event_then_http_callback_with_default_body(
self, subscription):
self.bus.publish(
trigger_event(data={'keý': 'vàlue'}),
routing_key=SOME_ROUTING_KEY,
headers={'name': TRIGGER_EVENT_NAME},
)
until.assert_(
self.make_third_party_verify_callback(
request={
'method':
'GET',
'path':
'/test',
'body':
'{"ke\\u00fd": "v\\u00e0lue"}',
'headers': [{
'name': 'Content-Type',
'values': ['application/json; charset=utf-8'],
}],
}),
timeout=10,
interval=0.5,
)
def test_given_mobile_call_when_relocate_to_line_then_relocate_completed(
self):
mobile_channel, other_channel, mobile_user_uuid = self.given_mobile_call(
)
token = self.given_user_token(mobile_user_uuid)
line_id = SOME_LINE_ID
calld = self.make_calld(token)
self.confd.set_users(
MockUser(uuid=mobile_user_uuid, line_ids=[line_id]))
self.confd.set_lines(
MockLine(id=line_id,
name='recipient_autoanswer@local',
protocol='local',
context=SOME_CONTEXT))
destination = 'line'
location = {'line_id': line_id}
relocate = calld.relocates.create_from_user(mobile_channel,
destination, location)
until.assert_(
self.assert_relocate_is_completed,
relocate['uuid'],
relocate['relocated_call'],
relocate['initiator_call'],
relocate['recipient_call'],
timeout=5,
)
def test_given_http_subscription_with_body_template_when_bus_event_then_callback_with_body_templated(
self, subscription):
self.bus.publish(
trigger_event(data={'variable': 'value'}),
routing_key=SOME_ROUTING_KEY,
headers={'name': TRIGGER_EVENT_NAME},
)
until.assert_(
self.make_third_party_verify_callback(request={
'method': 'GET',
'path': '/test',
'body': 'trigger value'
}),
timeout=10,
interval=0.5,
)
webhookd = self.make_webhookd(MASTER_TOKEN)
logs = webhookd.subscriptions.get_logs(subscription["uuid"])
assert_that(logs['total'], equal_to(1))
assert_that(
logs['items'],
contains(
has_entries(
status="success",
detail=has_entries(request_body='trigger value'),
attempts=1,
)),
)
def _assert_chat_msg_sent_on_bus(self):
def assert_function():
destination = [
self.chat_msg.to_xivo_uuid or XIVO_UUID, self.chat_msg.to
]
assert_that(
self.events.accumulate(),
has_items(
{
'name':
'chat_message_event',
'origin_uuid':
XIVO_UUID,
'required_acl':
'events.chat.message.{}.{}'.format(*destination),
'data': {
'alias': self.chat_msg.alias,
'to': destination,
'from': [XIVO_UUID, self.chat_msg.from_],
'msg': self.chat_msg.content,
}
},
has_entry('name', 'chat_message_received'),
has_entry('name', 'chat_message_sent'),
))
until.assert_(assert_function, tries=5)
def test_create(self, user):
routing_key = 'auth.users.{}.external.foo.created'.format(user['uuid'])
msg_accumulator = self.new_message_accumulator(routing_key)
result = self.client.external.create('foo', user['uuid'],
self.original_data)
assert_that(result, has_entries(**self.original_data))
def bus_received_msg():
assert_that(
msg_accumulator.accumulate(),
contains(
has_entries(data=dict(user_uuid=user['uuid'],
external_auth_name='foo'))),
)
until.assert_(bus_received_msg, tries=10, interval=0.25)
data = self.client.external.get('foo', user['uuid'])
assert_that(data, has_entries(**self.original_data))
base.assert_http_error(404, self.client.external.create, 'notfoo',
user['uuid'], self.original_data)
base.assert_http_error(404, self.client.external.create, 'foo',
UNKNOWN_UUID, self.original_data)
def test_given_dialed_from_when_originator_hangs_up_then_user_stops_ringing(self):
call_id = 'call-id'
new_call_id = 'new-call-id'
self.ari.set_channels(MockChannel(id=call_id),
MockChannel(id=new_call_id, ))
self.ari.set_channel_variable({new_call_id: {'XIVO_USERUUID': 'user-uuid'}})
self.ari.set_global_variables({'XIVO_CHANNELS_{}'.format(call_id): json.dumps({'app': 'my-app',
'app_instance': 'sw1',
'state': 'ringing'})})
self.confd.set_users(MockUser(uuid='user-uuid'))
self.confd.set_lines(MockLine(id='line-id', name='line-name', protocol='sip'))
self.confd.set_user_lines({'user-uuid': [MockUserLine('line-id')]})
self.ari.set_originates(MockChannel(id=new_call_id))
self.ctid_ng.connect_user(call_id, 'user-uuid')
self.stasis.event_hangup(call_id)
def assert_function():
assert_that(self.ari.requests(), has_entry('requests', has_items(has_entries({
'method': 'DELETE',
'path': '/ari/channels/{call_id}'.format(call_id=new_call_id),
}))))
until.assert_(assert_function, tries=5)
def test_given_one_http_subscription_with_no_body_when_bus_event_then_http_callback_with_default_body(
self, subscription):
third_party = self.make_third_party()
bus = self.make_bus()
bus.publish(trigger_event(data={'keý': 'vàlue'}),
routing_key=SOME_ROUTING_KEY,
headers={'name': TRIGGER_EVENT_NAME})
def callback_received():
try:
third_party.verify(
request={
'method':
'GET',
'path':
'/test',
'body':
'{"ke\\u00fd": "v\\u00e0lue"}',
'headers': [{
'name': 'Content-Type',
'values': ['application/json']
}],
})
except Exception:
raise AssertionError()
until.assert_(callback_received, tries=10, interval=0.5)
def test_given_two_http_subscription_when_one_deleted_then_one_http_callback(
self, subscription, subscription_to_remove):
bus = self.make_bus()
third_party = self.make_third_party()
webhookd = self.make_webhookd(VALID_TOKEN)
webhookd.subscriptions.delete(subscription_to_remove['uuid'])
time.sleep(1) # wait for the subscription to be removed
bus.publish(trigger_event(),
routing_key=SOME_ROUTING_KEY,
headers={'name': TRIGGER_EVENT_NAME})
def callback_received_once():
try:
third_party.verify(
request={
'method': 'GET',
'path': '/test',
},
count=1,
exact=True,
)
except Exception:
raise AssertionError()
until.assert_(callback_received_once, tries=10, interval=0.5)
def test_when_channel_resumed_then_bus_event(self):
call_id = new_call_id()
self.ari.set_channels(MockChannel(id=call_id))
self.ari.set_channel_variable({call_id: {'XIVO_ON_HOLD': ''}})
events = self.bus.accumulator(routing_key='calls.hold.deleted')
self.bus.send_ami_unhold_event(call_id)
def assert_function():
assert_that(
self.amid.requests()['requests'],
has_item(
has_entries({
'method':
'POST',
'path':
'/1.0/action/Setvar',
'json':
has_entries({
'Channel': call_id,
'Variable': 'XIVO_ON_HOLD',
'Value': ''
}),
})))
assert_that(
events.accumulate(),
has_item(
has_entries({
'name': 'call_resumed',
'origin_uuid': XIVO_UUID,
'data': has_entries({'call_id': call_id})
})))
until.assert_(assert_function, tries=5)
def test_external_oauth2(self, user):
routing_key = 'auth.users.{}.external.foo.authorized'.format(
user['uuid'])
msg_accumulator = self.new_message_accumulator(routing_key)
token = 'a-token'
result = self.client.external.create('foo', user['uuid'],
self.original_data)
time.sleep(1) # wazo-auth needs some time to connect its websocket
self.authorize_oauth2('foo', result['state'], token)
def oauth2_is_done():
try:
return self.client.external.get('foo', user['uuid'])
except requests.HTTPError:
return False
data = until.true(oauth2_is_done, timeout=5, interval=0.25)
assert_that(data, has_entries(access_token=token))
def bus_received_msg():
assert_that(
msg_accumulator.accumulate(),
contains(
has_entries(data=dict(user_uuid=user['uuid'],
external_auth_name='foo'))))
until.assert_(bus_received_msg, tries=10, interval=0.25)
def test_given_one_http_subscription_when_update_events_then_callback_triggered_on_the_right_event(
self, subscription):
bus = self.make_bus()
third_party = self.make_third_party()
webhookd = self.make_webhookd(VALID_TOKEN)
old_trigger_name = TRIGGER_EVENT_NAME
subscription['events'] = [ANOTHER_TRIGGER_EVENT_NAME]
webhookd.subscriptions.update(subscription['uuid'], subscription)
time.sleep(1) # wait for the subscription to be updated
bus.publish(event(name=old_trigger_name),
routing_key=SOME_ROUTING_KEY,
headers={'name': old_trigger_name})
bus.publish(event(name=ANOTHER_TRIGGER_EVENT_NAME),
routing_key=SOME_ROUTING_KEY,
headers={'name': ANOTHER_TRIGGER_EVENT_NAME})
def callback_received():
try:
third_party.verify(request={
'method': 'GET',
'path': '/test',
},
count=1,
exact=True)
except Exception:
raise AssertionError()
until.assert_(callback_received, tries=10, interval=0.5)
def test_when_channel_created_then_bus_event(self):
call_id = new_call_id()
self.ari.set_channels(MockChannel(id=call_id,
connected_line_number=''))
self.ari.set_channel_variable({
call_id: {
'XIVO_BASE_EXTEN': '*10',
'CHANNEL(channeltype)': 'PJSIP',
'CHANNEL(pjsip,call-id)': 'a-sip-call-id',
},
})
events = self.bus.accumulator(routing_key='calls.call.created')
self.bus.send_ami_newchannel_event(call_id)
def assert_function():
assert_that(
events.accumulate(),
has_item(
has_entries({
'name':
'call_created',
'origin_uuid':
XIVO_UUID,
'data':
has_entries({
'call_id': call_id,
'dialed_extension': '*10',
'peer_caller_id_number': '*10',
'sip_call_id': 'a-sip-call-id',
})
})))
until.assert_(assert_function, tries=5)
def test_when_channel_ended_with_sip_call_id_then_bus_event(self):
call_id = new_call_id()
sip_call_id = 'foobar'
events = self.bus.accumulator(routing_key='calls.call.ended')
self.bus.send_ami_hangup_event(call_id,
base_exten='*10',
sip_call_id=sip_call_id)
def assert_function():
assert_that(
events.accumulate(),
has_item(
has_entries({
'name':
'call_ended',
'origin_uuid':
XIVO_UUID,
'data':
has_entries({
'call_id': call_id,
'dialed_extension': '*10',
'sip_call_id': sip_call_id,
})
})))
until.assert_(assert_function, tries=5)
def test_send_fax_pdf(self):
calld = self.make_calld()
with open(os.path.join(ASSET_ROOT, 'fax', 'fax.pdf'),
'rb') as fax_file:
fax_content = fax_file.read()
fax = calld.faxes.send(fax_content,
context='recipient',
extension='recipient-fax',
caller_id='fax wait')
assert_that(
fax,
has_entries({
'id': is_not(empty()),
'context': 'recipient',
'extension': 'recipient-fax',
'caller_id': 'fax wait',
}))
def one_fax_channel():
assert_that(self._fax_channels(), has_length(1))
until.assert_(one_fax_channel, timeout=3)
def test_send_fax_pdf_from_user(self):
user_uuid = 'some-user-id'
context = 'user-context'
token = 'my-user-token'
self.auth.set_token(
MockUserToken(token, user_uuid=user_uuid, tenant_uuid='my-tenant'))
self.confd.set_users(
MockUser(uuid=user_uuid, line_ids=['some-line-id']))
self.confd.set_lines(
MockLine(id='some-line-id',
name='line-name',
protocol='pjsip',
context=context))
calld = self.make_calld(token)
with open(os.path.join(ASSET_ROOT, 'fax', 'fax.pdf'),
'rb') as fax_file:
fax_content = fax_file.read()
try:
calld.faxes.send_from_user(fax_content,
extension='recipient-fax',
caller_id='fax wait')
except Exception as e:
raise AssertionError(
'Sending fax raised an exception: {}'.format(e))
def one_fax_channel():
assert_that(self._fax_channels(), has_length(1))
until.assert_(one_fax_channel, timeout=3)
def test_given_dialed_from_when_answer_then_the_two_are_talking(self):
call_id = new_call_id()
new_call_id_ = new_call_id()
self.ari.set_channels(MockChannel(id=call_id), MockChannel(id=new_call_id_))
self.ari.set_global_variables({'XIVO_CHANNELS_{}'.format(call_id): json.dumps({'state': 'ringing',
'app': STASIS_APP_NAME,
'app_instance': STASIS_APP_INSTANCE_NAME})})
self.stasis.event_answer_connect(from_=call_id, new_call_id=new_call_id_)
def assert_function():
assert_that(self.ari.requests(), has_entry('requests', has_items(has_entries({
'method': 'POST',
'path': '/ari/channels/{channel_id}/answer'.format(channel_id=call_id),
}), has_entries({
'method': 'POST',
'path': '/ari/channels/{channel_id}/answer'.format(channel_id=new_call_id_),
}), has_entries({
'method': 'POST',
'path': '/ari/bridges/bridge-id/addChannel',
'query': [['channel', call_id]],
}), has_entries({
'method': 'POST',
'path': '/ari/bridges/bridge-id/addChannel',
'query': [['channel', new_call_id_]],
}), has_entries({
'method': 'POST',
'path': '/ari/bridges',
'query': [['type', 'mixing']],
}))))
until.assert_(assert_function, tries=5)
def test_given_http_subscription_with_content_type_when_bus_event_then_http_callback_with_content_type(
self, subscription):
third_party = self.make_third_party()
bus = self.make_bus()
bus.publish(trigger_event(),
routing_key=SOME_ROUTING_KEY,
headers={'name': TRIGGER_EVENT_NAME})
def callback_received():
try:
third_party.verify(
request={
'method':
'POST',
'path':
'/test',
'body':
'keỳ: vàlue',
'headers': [{
'name': 'Content-Type',
'values': ['text/yaml']
}],
})
except Exception:
raise AssertionError()
until.assert_(callback_received, tries=10, interval=0.5)
def test_given_http_subscription_with_url_template_when_bus_event_then_callback_with_url_templated(
self, subscription):
third_party = self.make_third_party()
bus = self.make_bus()
bus.publish(trigger_event(data={
'variable': 'value',
'another_variable': 'another_value'
}),
routing_key=SOME_ROUTING_KEY,
headers={'name': TRIGGER_EVENT_NAME})
def callback_received():
try:
third_party.verify(
request={
'method':
'GET',
'path':
'/test/value',
'queryStringParameters': [{
'name': 'variable',
'value': 'value'
}, {
'name': 'another_variable',
'value': 'another_value'
}]
})
except Exception:
raise AssertionError()
until.assert_(callback_received, tries=10, interval=0.5)
def test_when_asterisk_restart_then_ctid_ng_reconnects(self):
until.assert_(self._ctid_ng_is_connected, tries=3)
self.restart_service('ari')
assert_that(self.service_logs(), contains_string("ARI connection error"))
until.assert_(self._ctid_ng_is_connected, tries=3)
def test_when_channel_ends_then_stat_channel_ended(self):
channel_id = 'channel-id'
self.bus.listen_events(routing_key='collectd.channels', exchange='collectd')
self.bus.send_ami_hangup_event(channel_id=channel_id)
def assert_function():
expected_message = 'PUTVAL [^/]+/channels-global/counter-ended .* N:1'
assert_that(self.bus.events(), has_item(matches_regexp(expected_message)))
until.assert_(assert_function, tries=5)
def _assert_presence_msg_sent_on_bus(self):
def assert_function():
assert_that(self.bus.events(), has_item(equal_to({
'name': 'user_status_update',
'origin_uuid': XIVO_UUID,
'required_acl': 'events.statuses.users',
'data': {
'user_uuid': self.token_user_uuid,
'status': 'available',
}
})))
until.assert_(assert_function, tries=5)
def test_when_new_stasis_channel_then_stat_call_start(self):
call_id = new_call_id()
self.ari.set_channels(MockChannel(id=call_id))
self.bus.listen_events(routing_key='collectd.calls', exchange='collectd')
self.stasis.event_stasis_start(channel_id=call_id)
def assert_function():
expected_message = 'PUTVAL [^/]+/calls-{app}.{app_instance}/counter-start .* N:1'
expected_message = expected_message.format(app=STASIS_APP_NAME,
app_instance=STASIS_APP_INSTANCE_NAME)
assert_that(self.bus.events(), has_item(matches_regexp(expected_message)))
until.assert_(assert_function, tries=5)
def test_given_connected_when_stasis_channel_destroyed_then_do_not_stat_abandoned_call(self):
call_id = new_call_id()
self.ari.set_channels(MockChannel(id=call_id))
self.bus.listen_events(routing_key='collectd.calls', exchange='collectd')
self.stasis.event_stasis_start(channel_id=call_id)
self.stasis.event_channel_destroyed(channel_id=call_id,
connected_number='another-number')
def assert_function():
expected_message = 'PUTVAL [^/]+/calls-{app}.{app_instance}/counter-abandoned .* N:1'
expected_message = expected_message.format(app=STASIS_APP_NAME,
app_instance=STASIS_APP_INSTANCE_NAME)
assert_that(self.bus.events(), not_(has_item(matches_regexp(expected_message))))
until.assert_(assert_function, tries=3)
def test_given_ctid_ng_restarts_during_call_when_stasis_channel_destroyed_then_stat_call_end(self):
call_id = new_call_id()
self.ari.set_channels(MockChannel(id=call_id))
self.bus.listen_events(routing_key='collectd.calls', exchange='collectd')
self.stasis.event_stasis_start(channel_id=call_id)
self.restart_service('ctid-ng')
until.true(self.ari.websockets, tries=5) # wait for xivo-ctid-ng to come back up
self.stasis.event_channel_destroyed(channel_id=call_id)
def assert_ctid_ng_sent_end_call_stat():
expected_message = 'PUTVAL [^/]+/calls-{app}.{app_instance}/counter-end .* N:1'
expected_message = expected_message.format(app=STASIS_APP_NAME,
app_instance=STASIS_APP_INSTANCE_NAME)
assert_that(self.bus.events(), has_item(matches_regexp(expected_message)))
until.assert_(assert_ctid_ng_sent_end_call_stat, tries=5)
def test_when_stasis_channel_destroyed_then_stat_call_duration(self):
call_id = new_call_id()
self.ari.set_channels(MockChannel(id=call_id))
self.bus.listen_events(routing_key='collectd.calls', exchange='collectd')
self.stasis.event_stasis_start(channel_id=call_id)
self.stasis.event_channel_destroyed(channel_id=call_id,
creation_time='2016-02-01T15:00:00.000-0500',
timestamp='2016-02-01T16:00:00.000-0500')
def assert_function():
expected_message = 'PUTVAL [^/]+/calls-{app}.{app_instance}/gauge-duration .* N:3600'
expected_message = expected_message.format(app=STASIS_APP_NAME,
app_instance=STASIS_APP_INSTANCE_NAME)
assert_that(self.bus.events(), has_item(matches_regexp(expected_message)))
until.assert_(assert_function, tries=5)
def test_given_rabbitmq_restarts_during_call_when_stasis_channel_destroyed_then_stat_call_end(self):
call_id = new_call_id()
self.ari.set_channels(MockChannel(id=call_id))
self.stasis.event_stasis_start(channel_id=call_id)
self.restart_service('rabbitmq')
until.true(self.bus.is_up, tries=int(os.environ.get('INTEGRATION_TEST_TIMEOUT', 30))) # wait for rabbitmq to come back up
self.bus.listen_events(routing_key='collectd.calls', exchange='collectd')
self.stasis.event_channel_destroyed(channel_id=call_id)
def assert_ctid_ng_sent_end_call_stat():
expected_message = 'PUTVAL [^/]+/calls-{app}.{app_instance}/counter-end .* N:1'
expected_message = expected_message.format(app=STASIS_APP_NAME,
app_instance=STASIS_APP_INSTANCE_NAME)
assert_that(self.bus.events(), has_item(matches_regexp(expected_message)))
until.assert_(assert_ctid_ng_sent_end_call_stat, tries=5)
