def test_get_secondary_user_associated_to_line(main_user, other_user, line):
expected = has_item(has_entries({'user_id': other_user['id'],
'line_id': line['id'],
'main_user': False,
'main_line': True}))
with a.user_line(main_user, line), a.user_line(other_user, line):
response = confd.lines(line['id']).users.get()
assert_that(response.items, expected)
def test_associate_two_internal_extensions_to_same_line(
first_extension, second_extension, line):
associate = confd.lines(line['id']).extensions
response = associate.post(extension_id=first_extension['id'])
response.assert_created('lines', 'extensions')
response = associate.post(extension_id=second_extension['id'])
response.assert_match(400, e.resource_associated('Line', 'Extension'))
def test_get_user_associated_to_line(user, line):
expected = contains(has_entries({'user_id': user['id'],
'line_id': line['id'],
'main_user': True,
'main_line': True}))
with a.user_line(user, line):
response = confd.lines(line['id']).users.get()
assert_that(response.items, expected)
def test_associate_line_and_incall(user, line, internal, incall):
expected = has_entries({
'line_id': line['id'],
'extension_id': incall['id']
})
with a.user_line(user, line):
response = confd.lines(
line['id']).extensions.post(extension_id=incall['id'])
assert_that(response.item, expected)
def test_dissociate_extension_then_line_then_user(user, line, extension):
with a.user_line(user, line, check=False), a.line_extension(line,
extension,
check=False):
response = confd.lines(line['id']).extensions(extension['id']).delete()
response.assert_deleted()
response = confd.users(user['id']).lines(line['id']).delete()
response.assert_deleted()
def test_given_extension_associated_to_sccp_line_when_updated_then_cid_num_updated(
user, line, sccp, extension):
exten = h.extension.find_available_exten(config.CONTEXT)
with a.line_endpoint_sccp(line, sccp), a.line_extension(
line, extension), a.user_line(user, line):
confd.extensions(extension['id']).put(exten=exten).assert_updated()
response = confd.lines(line['id']).get()
assert_that(response.item, has_entries(caller_id_num=exten))
def test_associate_line_and_extension(line, extension):
expected = has_entries({
'line_id': line['id'],
'extension_id': extension['id']
})
response = confd.lines(
line['id']).extension.post(extension_id=extension['id'])
response.assert_created('lines', 'extension')
assert_that(response.item, expected)
def test_post_errors():
empty_post = confd.lines.post
line_post = confd.lines(context=config.CONTEXT).post
yield s.check_missing_required_field_returns_error, empty_post, 'context'
yield s.check_bogus_field_returns_error, empty_post, 'context', 123
yield s.check_bogus_field_returns_error, line_post, 'provisioning_code', 123456
yield s.check_bogus_field_returns_error, line_post, 'provisioning_code', 'number'
yield s.check_bogus_field_returns_error, line_post, 'position', 'one'
yield s.check_bogus_field_returns_error, line_post, 'registrar', 123
yield s.check_bogus_field_returns_error, line_post, 'registrar', 'invalidregistrar'
def test_associate_user_line_extension(user, line, extension):
expected = has_entries({
'line_id': line['id'],
'extension_id': extension['id']
})
with a.user_line(user, line, check=False):
response = confd.lines(
line['id']).extension.post(extension_id=extension['id'])
response.assert_created('lines', 'extension')
assert_that(response.item, expected)
def test_associate_line_with_endpoint(line, sip, extension):
with a.line_endpoint_sip(line, sip, check=False):
url = confd.lines(line['id']).extensions
response = url.post(extension_id=extension['id'])
response.assert_created('lines', 'extensions')
assert_that(
response.item,
has_entries({
'line_id': line['id'],
'extension_id': extension['id']
}))
def test_caller_id_on_sccp_line(user, line, sccp, extension):
with a.line_endpoint_sccp(line, sccp), a.user_line(user,
line), a.line_extension(
line, extension):
response = confd.lines(line['id']).get()
assert_that(
response.item,
has_entries({
'caller_id_name': 'Jôhn Smîth',
'caller_id_num': extension['exten']
}))
def test_get_line_extension_associations(user, line, internal, incall):
expected = has_items(
has_entries({
'line_id': line['id'],
'extension_id': internal['id']
}), has_entries({
'line_id': line['id'],
'extension_id': incall['id']
}))
with a.user_line(user, line), a.line_extension(line,
internal), a.line_extension(
line, incall):
response = confd.lines(line['id']).extensions.get()
assert_that(response.items, expected)
def test_given_backup_registrar_has_changed_when_sccp_line_updated_then_provd_updated(
provd, user, line, sccp, extension, device):
registrar = provd.configs.get('default')
registrar['proxy_backup'] = '20.2.3.4'
provd.configs.update(registrar)
with a.line_endpoint_sccp(line, sccp), a.user_line(user, line), \
a.line_extension(line, extension), a.line_device(line, device):
response = confd.lines(line['id']).put()
response.assert_updated()
provd_config = provd.configs.get(device['id'])
sccp_config = provd_config['raw_config']['sccp_call_managers']['2']
assert_that(sccp_config, has_entries(ip='20.2.3.4'))
def test_get(line):
expected = has_entries({
'context': config.CONTEXT,
'position': 1,
'device_slot': 1,
'name': none(),
'protocol': none(),
'device_id': none(),
'caller_id_name': none(),
'caller_id_num': none(),
'registrar': 'default',
'provisioning_code': has_length(6),
'provisioning_extension': has_length(6)
})
response = confd.lines(line['id']).get()
assert_that(response.item, expected)
def test_put_errors(line, sip):
line_put = confd.lines(line['id']).put
yield s.check_missing_required_field_returns_error, line_put, 'context'
yield s.check_bogus_field_returns_error, line_put, 'context', 123
yield s.check_bogus_field_returns_error, line_put, 'provisioning_code', 123456
yield s.check_bogus_field_returns_error, line_put, 'provisioning_code', 'number'
yield s.check_bogus_field_returns_error, line_put, 'provisioning_code', None
yield s.check_bogus_field_returns_error, line_put, 'position', 'one'
yield s.check_bogus_field_returns_error, line_put, 'position', None
yield s.check_bogus_field_returns_error, line_put, 'registrar', None
yield s.check_bogus_field_returns_error, line_put, 'registrar', 123
yield s.check_bogus_field_returns_error, line_put, 'registrar', 'invalidregistrar'
with a.line_endpoint_sip(line, sip):
yield s.check_bogus_field_returns_error, line_put, 'caller_id_num', 'number'
yield s.check_bogus_field_returns_error, line_put, 'caller_id_name', 123456
def test_when_caller_id_updated_on_line_then_provd_is_updated(
user, line, extension, device):
with a.user_line(user, line), a.line_extension(line,
extension), a.line_device(
line, device):
response = confd.lines(line['id']).put(caller_id_name="jôhn smîth",
caller_id_num="1000")
response.assert_updated()
provd_config = provd.configs.get(device['id'])
sip_line = provd_config['raw_config']['sip_lines']['1']
assert_that(
sip_line,
has_entries({
'display_name': 'jôhn smîth',
'number': extension['exten']
}))
def test_given_config_registrar_has_changed_when_sip_line_updated_then_provd_updated(
provd, user, line, sip, extension, device):
registrar = provd.configs.get('default')
registrar['registrar_main'] = '10.0.1.2'
registrar['proxy_main'] = '11.1.2.3'
provd.configs.update(registrar)
with a.line_endpoint_sip(line, sip), a.user_line(user, line), \
a.line_extension(line, extension), a.line_device(line, device):
response = confd.lines(line['id']).put()
response.assert_updated()
provd_config = provd.configs.get(device['id'])
sip_line = provd_config['raw_config']['sip_lines']['1']
assert_that(sip_line,
has_entries(registrar_ip='10.0.1.2', proxy_ip='11.1.2.3'))
def test_when_extension_updated_on_sip_line_then_provd_is_updated(
user, line, sip, extension, device):
exten = h.extension.find_available_exten(config.CONTEXT)
line_cid = h.extension.find_available_exten(config.CONTEXT,
exclude=[exten])
with a.line_endpoint_sip(line, sip), a.user_line(user, line), \
a.line_extension(line, extension), a.line_device(line, device):
response = confd.extensions(extension['id']).put(exten=exten)
response.assert_updated()
response = confd.lines(line['id']).put(caller_id_num=line_cid)
response.assert_updated()
provd_config = provd.configs.get(device['id'])
sip_line = provd_config['raw_config']['sip_lines']['1']
assert_that(sip_line, has_entries(number=exten))
def test_updating_user_line_or_extension_associated_with_autoprov_device_does_not_fail(
user, line, sip, extension, device):
with a.line_endpoint_sip(line, sip, check=False), a.line_extension(line, extension, check=False), \
a.user_line(user, line, check=False):
with db.queries() as queries:
queries.associate_line_device(line['id'], device['id'])
response = confd.endpoints.sip(sip['id']).put()
response.assert_ok()
response = confd.lines(line['id']).put()
response.assert_ok()
response = confd.users(user['id']).put()
response.assert_ok()
response = confd.extensions(extension['id']).put()
response.assert_ok()
def test_update_all_parameters_on_line(line, context, registrar):
url = confd.lines(line['id'])
expected = has_entries({
'context': context['name'],
'position': 2,
'caller_id_name': none(),
'caller_id_num': none(),
'registrar': registrar['id'],
'provisioning_code': '243546'
})
response = url.put(context=context['name'],
position=2,
registrar=registrar['id'],
provisioning_code='243546')
response.assert_updated()
response = url.get()
assert_that(response.item, expected)
def dissociate(line_id, endpoint_id, check=True):
response = confd.lines(line_id).endpoints.sip(endpoint_id).delete()
if check:
response.assert_ok()
def associate(line_id, extension_id):
response = confd.lines(line_id).extensions.post(extension_id=extension_id)
response.assert_ok()
def test_dissociate_line_and_incall(user, line, internal, incall):
with a.user_line(user, line), a.line_extension(line, incall, check=False):
response = confd.lines(line['id']).extensions(incall['id']).delete()
response.assert_deleted()
def dissociate(line_id, extension_id):
response = confd.lines(line_id).extensions(extension_id).delete()
response.assert_ok()
def test_get_custom_endpoint_after_dissociation(line, custom):
h.line_endpoint_custom.associate(line['id'], custom['id'])
h.line_endpoint_custom.dissociate(line['id'], custom['id'])
response = confd.lines(line['id']).endpoints.custom.get()
response.assert_status(404)
def test_get_errors():
fake_line = confd.lines(999999999).endpoints.custom.get
fake_custom = confd.endpoints.custom(999999999).lines.get
yield s.check_resource_not_found, fake_line, 'Line'
yield s.check_resource_not_found, fake_custom, 'CustomEndpoint'
def test_dissociate_errors(line, custom):
fake_line = confd.lines(999999999).endpoints.custom(custom['id']).delete
fake_custom = confd.lines(line['id']).endpoints.custom(999999999).delete
yield s.check_resource_not_found, fake_line, 'Line'
yield s.check_resource_not_found, fake_custom, 'CustomEndpoint'
def test_dissociate_when_associated_to_extension(line, custom, extension):
with a.line_endpoint_custom(line,
custom), a.line_extension(line, extension):
response = confd.lines(line['id']).endpoints.custom(
custom['id']).delete()
response.assert_match(400, e.resource_associated('Line', 'Extension'))
def test_dissociate_when_associated_to_user(line, custom, user):
with a.line_endpoint_custom(line, custom), a.user_line(user, line):
response = confd.lines(line['id']).endpoints.custom(
custom['id']).delete()
response.assert_match(400, e.resource_associated('Line', 'User'))
def test_dissociate_when_not_associated(line, custom):
response = confd.lines(line['id']).endpoints.custom(custom['id']).delete()
response.assert_status(400)
def test_dissociate(line, custom):
with a.line_endpoint_custom(line, custom, check=False):
response = confd.lines(line['id']).endpoints.custom(
custom['id']).delete()
response.assert_deleted()
def test_associate_with_another_endpoint_when_already_associated(
line, custom1, custom2):
with a.line_endpoint_custom(line, custom1):
response = confd.lines(line['id']).endpoints.custom(
custom2['id']).put()
response.assert_match(400, e.resource_associated('Line', 'Endpoint'))
