def test_post(self, tenant, foobaz): assert_that( foobaz, has_entries( uuid=uuid_(), name='foobaz', slug='foobaz', description=none(), acl=empty(), shared=False, tenant_uuid=self.top_tenant_uuid, ), ) policy_args = { 'name': 'foobar', 'slug': 'slug1', 'description': 'a test policy', 'acl': ['dird.me.#', 'ctid-ng.#'], 'shared': False, 'tenant_uuid': tenant['uuid'], } # Specify the tenant_uuid with self.policy(self.client, **policy_args) as policy: assert_that(policy, has_entries(uuid=uuid_(), name='foobar')) # Specify the tenant uuid in another sub-tenant tree with self.client_in_subtenant() as (client, _, __): assert_http_error(401, client.policies.new, **policy_args) # Invalid body assert_http_error(400, self.client.policies.new, '')
def test_email_updates_as_admin(self, foobar): assert_http_error(404, self.client.admin.update_user_emails, UNKNOWN_UUID, []) assert_http_error(400, self.client.users.update_emails, foobar['uuid'], [ONE, ONE]) result = self.client.admin.update_user_emails(foobar['uuid'], [ONE, TWO]) assert_that( result, contains_inanyorder(has_entries(uuid=uuid_(), **ONE), has_entries(uuid=uuid_(), **TWO)), ) one_uuid = [ entry['uuid'] for entry in result if entry['address'] == '*****@*****.**' ][0] result = self.client.admin.update_user_emails(foobar['uuid'], [ONE, THREE]) assert_that( result, contains_inanyorder(has_entries(uuid=one_uuid, **ONE), has_entries(uuid=uuid_(), **THREE)), )
def test_multi_tenant(self): main_tenant_client = self.get_client(VALID_TOKEN_MAIN_TENANT) sub_tenant_client = self.get_client(VALID_TOKEN_SUB_TENANT) with self.source(main_tenant_client, self.valid_body) as result: assert_that(result, has_entries(uuid=uuid_(), tenant_uuid=MAIN_TENANT)) with self.source(main_tenant_client, self.valid_body, tenant_uuid=SUB_TENANT) as result: assert_that(result, has_entries(uuid=uuid_(), tenant_uuid=SUB_TENANT)) with self.source(sub_tenant_client, self.valid_body) as result: assert_that(result, has_entries(uuid=uuid_(), tenant_uuid=SUB_TENANT)) assert_that( calling(sub_tenant_client.backends.create_source).with_args( 'google', self.valid_body, tenant_uuid=MAIN_TENANT), raises(Exception).matching(HTTP_401), ) with self.source(main_tenant_client, self.valid_body): assert_that( calling(sub_tenant_client.backends.create_source).with_args( 'google', self.valid_body), not_(raises(Exception)), )
def test_multi_tenant(self): main_tenant_client = self.get_client(VALID_TOKEN_MAIN_TENANT) sub_tenant_client = self.get_client(VALID_TOKEN_SUB_TENANT) with self.source(main_tenant_client, self.valid_body) as result: assert_that(result, has_entries(uuid=uuid_(), tenant_uuid=MAIN_TENANT)) with self.source(main_tenant_client, self.valid_body, tenant_uuid=SUB_TENANT) as result: assert_that(result, has_entries(uuid=uuid_(), tenant_uuid=SUB_TENANT)) with self.source(sub_tenant_client, self.valid_body) as result: assert_that(result, has_entries(uuid=uuid_(), tenant_uuid=SUB_TENANT)) assert_that( calling(sub_tenant_client.phonebook_source.create).with_args( self.valid_body, tenant_uuid=MAIN_TENANT), raises(Exception).matching( has_properties(response=has_properties(status_code=401))), ) with self.source(main_tenant_client, self.valid_body): assert_that( calling(sub_tenant_client.phonebook_source.create).with_args( self.valid_body), not_(raises(Exception)), )
def test_token_creation(self, user): response = self._post_token(user['username'], 's3cr37', backend='wazo_user') assert_that( response, has_entries( token=uuid_(), auth_id=user['uuid'], xivo_user_uuid=user['uuid'], # For API compatibility reason acl=has_item('default.user.policy'), session_uuid=uuid_(), metadata=has_entries(pbx_user_uuid=user['uuid']), ), ) assert_http_error( 401, self._post_token, user['username'], 'not-our-password', backend='wazo_user', ) assert_http_error(401, self._post_token, 'not-foobar', 's3cr37', backend='wazo_user')
def test_register_post(self): args = { 'username': '******', 'lastname': 'Denver', 'email_address': '*****@*****.**', 'password': '******', } with self.user(self.client, register=True, **args) as user: assert_that( user, has_entries( uuid=uuid_(), username='******', firstname=None, lastname='Denver', enabled=True, tenant_uuid=uuid_(), emails=contains_inanyorder( has_entries( uuid=uuid_(), address='*****@*****.**', main=True, confirmed=False, )), ), ) created_tenant = self.client.tenants.get(user['tenant_uuid']) assert_that( created_tenant, has_entries(uuid=is_not(self.top_tenant_uuid), parent_uuid=self.top_tenant_uuid), ) url = self.get_last_email_url() url = url.replace('https', 'http') requests.get(url) updated_user = self.client.users.get(user['uuid']) assert_that( updated_user, has_entries(emails=contains_exactly(has_entries( confirmed=True))), ) tenants = self.client.users.get_tenants(user['uuid']) assert_that( tenants, has_entries(items=contains_exactly(has_entries(uuid=uuid_()))))
def check(): response = self.client.backends.list_sources( 'google', tenant_uuid=self.tenant_uuid ) assert_that( response, has_entries( items=has_item( has_entries( uuid=uuid_(), tenant_uuid=self.tenant_uuid, name='auto_google_mytenant', auth={ 'host': 'localhost', 'port': 9497, 'prefix': None, 'https': False, 'version': '0.1', }, first_matched_columns=has_item('numbers'), searched_columns=contains_inanyorder( 'name', 'numbers', 'familyName', 'givenName' ), format_columns=has_entries( phone_mobile='{numbers_by_label[mobile]}', reverse='{name}', phone='{numbers_except_label[mobile][0]}', ), ) ) ), )
def test_user_creation_email_confirmed(self): username = '******' hash_ = 'the_hashed_password' email_address = '*****@*****.**' user_uuid = self._user_dao.create( username=username, email_address=email_address, tenant_uuid=self.top_tenant_uuid, hash_=hash_, salt=self.salt, purpose='user', email_confirmed=True, )['uuid'] try: result = self._user_dao.list_(uuid=user_uuid) assert_that( result, contains_exactly( has_entries( username=username, emails=contains_exactly( has_entries(uuid=uuid_(), address=email_address, confirmed=True)), )), ) finally: self._user_dao.delete(user_uuid)
def test_get(self, group1, group2, user1, user2, policy): response = self.client.policies.get(policy['uuid']) assert_that( response, has_entries( name='foobar', description='a test policy', acl=contains_inanyorder('service1.me.#', 'service2.#'), read_only=False, ), ) assert_http_error(404, self.client.policies.get, UNKNOWN_UUID) self.client.users.add_policy(user1['uuid'], policy['uuid']) self.client.users.add_policy(user2['uuid'], policy['uuid']) self.client.groups.add_policy(group1['uuid'], policy['uuid']) self.client.groups.add_policy(group2['uuid'], policy['uuid']) assert_that( self.client.policies.get(policy['uuid'])['acl'], contains_inanyorder('service1.me.#', 'service2.#'), ) with self.client_in_subtenant() as (client, _, __): assert_http_error(404, client.policies.get, policy['uuid']) policy_in_subtenant = client.policies.new(name='in sub-tenant') assert_that( self.client.policies.get(policy_in_subtenant['uuid']), has_entries(uuid=uuid_(), name='in sub-tenant'), )
def test_create_minimal_parameters(self): room_args = {'users': [{'uuid': UUID}]} room = self.chatd.rooms.create_from_user(room_args) assert_that( room, has_entries( uuid=uuid_(), name=none(), users=contains_inanyorder( has_entries( uuid=str(TOKEN_USER_UUID), tenant_uuid=str(TOKEN_TENANT_UUID), wazo_uuid=str(WAZO_UUID), ), has_entries( uuid=room_args['users'][0]['uuid'], tenant_uuid=str(TOKEN_TENANT_UUID), wazo_uuid=str(WAZO_UUID), ), ), ), ) self._delete_room(room)
def test_create(self): room_args = { 'name': 'test-room', 'users': [ { 'uuid': str(TOKEN_USER_UUID), 'tenant_uuid': str(TOKEN_TENANT_UUID), 'wazo_uuid': str(WAZO_UUID), }, { 'uuid': UUID, 'tenant_uuid': UUID, 'wazo_uuid': UUID }, ], } routing_key = 'chatd.users.*.rooms.created' event_accumulator = self.bus.accumulator(routing_key) room = self.chatd.rooms.create_from_user(room_args) assert_that( room, has_entries( uuid=uuid_(), name=room_args['name'], users=contains_inanyorder(*room_args['users']), ), ) event = event_accumulator.accumulate(with_headers=True) assert_that( event, contains_inanyorder( has_entries( message=has_entries( data=has_entries(room_args), required_acl= f'events.chatd.users.{TOKEN_USER_UUID}.rooms.created', ), headers=has_entries(tenant_uuid=str(TOKEN_TENANT_UUID)), ), has_entries( message=has_entries( data=has_entries(room_args), required_acl=f'events.chatd.users.{UUID}.rooms.created', ), headers=has_entries(tenant_uuid=str(TOKEN_TENANT_UUID)), ), ), ) self._delete_room(room)
def test_that_the_right_credentials_return_a_token_with_datas(self): response = self._post_token('foo', 'bar') assert_that( response, has_entries( token=uuid_(), metadata=has_entries(uuid=self.user['uuid']), acl=ANY, ), )
def test_minimal_body(self): with self.source(self.client, self.valid_body) as source: assert_that( source, has_entries( uuid=uuid_(), name='google', auth=has_entries(host='localhost', port=443, verify_certificate=True), ), )
def test_list(self): result = self.contacts(self.client, self.source_uuid) assert_that( result, has_entries( total=4, filtered=4, items=contains_inanyorder( has_entries( id=1, uuid=uuid_(), firstname='John', lastname='Doe', exten='1234', voicemail_number=None, mobile_phone_number='+14184765458', email='*****@*****.**', ), has_entries(firstname='Mary'), has_entries(firstname='Bob'), has_entries(firstname='Charles'), ), ), ) assert_that( result['items'][0].keys(), contains_inanyorder( 'id', 'uuid', 'firstname', 'lastname', 'exten', 'voicemail_number', 'mobile_phone_number', 'email', ), ) assert_that( calling(self.contacts).with_args(self.client, UNKNOWN_UUID), raises(Exception).matching( has_properties(response=has_properties(status_code=404))), )
def test_create_minimal_parameters(self, room): message_args = {'content': 'Message content'} message = self.chatd.rooms.create_message_from_user( room['uuid'], message_args) assert_that( message, has_entries( uuid=uuid_(), content=message_args['content'], alias=none(), user_uuid=str(TOKEN_USER_UUID), tenant_uuid=str(TOKEN_TENANT_UUID), wazo_uuid=str(WAZO_UUID), created_at=is_not(none()), room=has_entries(uuid=room['uuid']), ), )
def check(): response = self.client.conference_source.list(tenant_uuid=self.tenant_uuid) key_file = '/var/lib/wazo-auth-keys/wazo-dird-conference-backend-key.yml' assert_that( response, has_entries( items=has_item( has_entries( uuid=uuid_(), tenant_uuid=self.tenant_uuid, name='auto_conference_mytenant', auth={ 'host': 'localhost', 'port': 9497, 'prefix': None, 'https': False, 'version': '0.1', 'key_file': key_file, }, confd={ 'host': 'localhost', 'port': 9486, 'prefix': None, 'https': False, 'version': '1.1', }, first_matched_columns=contains_inanyorder( 'extensions', 'incalls' ), searched_columns=contains_inanyorder( 'name', 'extensions', 'incalls' ), format_columns={ 'phone': '{extensions[0]}', 'reverse': '{name}', }, ) ) ), )
def test_valid_post(self): body = { 'name': 'display', 'columns': [ {'field': 'fn', 'title': 'Firstname', 'default': ''}, { 'field': 'mobile', 'title': 'Mobile', 'type': 'number', 'number_display': '{firstname} (Mobile)', 'default': None, }, ], } with self.create(self.client, body) as display: assert_that( display, has_entries( uuid=uuid_(), tenant_uuid=MAIN_TENANT, columns=contains( has_entries( field='fn', title='Firstname', default='', type=None, number_display=None, ), has_entries( field='mobile', title='Mobile', type='number', number_display='{firstname} (Mobile)', default=None, ), ), ), )
def test_email_updates_as_user(self, foobar): assert_http_error(404, self.client.users.update_emails, UNKNOWN_UUID, []) assert_http_error(400, self.client.users.update_emails, foobar['uuid'], [ONE, ONE]) email_uuid = foobar['emails'][0]['uuid'] result = self.client.users.update_emails(foobar['uuid'], [ONE, THREE]) assert_that( result, contains_inanyorder( has_entries(uuid=email_uuid, **ONE), has_entries( uuid=uuid_(), address=THREE['address'], main=THREE['main'], confirmed=False, ), # Confirmed is ignored when modifying as a user ), ) result = self.client.users.update_emails(foobar['uuid'], []) assert_that(result, empty())
def test_post(self, foobar, foobaz, other): assert_that( other, has_entries( uuid=uuid_(), name=None, slug='slug3', parent_uuid=self.top_tenant_uuid, address=has_entries(**ADDRESS_NULL), domain_names=is_(empty()), ), ) assert_that( foobaz, has_entries( uuid='6668ca15-6d9e-4000-b2ec-731bc7316767', name='foobaz', slug='slug2', parent_uuid=self.top_tenant_uuid, address=has_entries(**ADDRESS_NULL), domain_names=contains_inanyorder(*VALID_DOMAIN_NAMES_2), ), ) assert_that( foobar, has_entries( uuid=uuid_(), name='foobar', slug='slug1', phone=PHONE_1, parent_uuid=self.top_tenant_uuid, address=has_entries(**ADDRESS_1), domain_names=contains_inanyorder(*VALID_DOMAIN_NAMES_1), ), ) wazo_all_users_groups = self.client.groups.list( search='wazo-all-users', recurse=True )['items'] assert_that( wazo_all_users_groups, contains_inanyorder( has_entries( name=f'wazo-all-users-tenant-{self.top_tenant_uuid}', tenant_uuid=self.top_tenant_uuid, ), has_entries( name=f'wazo-all-users-tenant-{foobar["uuid"]}', tenant_uuid=foobar['uuid'], ), has_entries( name=f'wazo-all-users-tenant-{foobaz["uuid"]}', tenant_uuid=foobaz['uuid'], ), has_entries( name=f'wazo-all-users-tenant-{other["uuid"]}', tenant_uuid=other['uuid'], ), ), ) def expected_policies(tenant_uuid): return contains_exactly( has_entries( slug=ALL_USERS_POLICY_SLUG, tenant_uuid=tenant_uuid, acl=has_item('integration_tests.access'), ) ) # Assert default policies from admin point of view (recurse=True) wazo_all_users_policies = [ { 'group': wazo_all_users_group, 'policies': self.client.groups.get_policies( wazo_all_users_group['uuid'], recurse=True )['items'], } for wazo_all_users_group in wazo_all_users_groups ] assert_that( wazo_all_users_policies, contains_inanyorder( has_entries( group=has_entries(tenant_uuid=self.top_tenant_uuid), policies=expected_policies(self.top_tenant_uuid), ), has_entries( group=has_entries(tenant_uuid=foobar['uuid']), policies=expected_policies(self.top_tenant_uuid), ), has_entries( group=has_entries(tenant_uuid=foobaz['uuid']), policies=expected_policies(self.top_tenant_uuid), ), has_entries( group=has_entries(tenant_uuid=other['uuid']), policies=expected_policies(self.top_tenant_uuid), ), ), ) # Assert default policies from tenant point of view result = [] for group in wazo_all_users_groups: self.client.tenant_uuid = group['tenant_uuid'] policies = self.client.groups.get_policies(group['uuid'])['items'] self.client.tenant_uuid = None result.append({'group': group, 'policies': policies}) assert_that( result, contains_inanyorder( has_entries( group=has_entries(tenant_uuid=self.top_tenant_uuid), policies=expected_policies(self.top_tenant_uuid), ), has_entries( group=has_entries(tenant_uuid=foobar['uuid']), policies=expected_policies(foobar['uuid']), ), has_entries( group=has_entries(tenant_uuid=foobaz['uuid']), policies=expected_policies(foobaz['uuid']), ), has_entries( group=has_entries(tenant_uuid=other['uuid']), policies=expected_policies(other['uuid']), ), ), ) tenant_uuids = [ self.top_tenant_uuid, foobar['uuid'], foobaz['uuid'], other['uuid'], ] slug = ALL_USERS_POLICY_SLUG for tenant_uuid in tenant_uuids: assert_that( self.client.tenants.get_policies(tenant_uuid)['items'], has_item(has_entries(slug=slug, tenant_uuid=tenant_uuid)), ) params = {'name': 'subtenant', 'parent_uuid': foobar['uuid']} with self.tenant(self.client, **params) as subtenant: assert_that(subtenant, has_entries(uuid=uuid_(), **params))
def test_post_with_top_tenant_admin(self, isolated): args = { 'username': '******', 'firstname': 'Alice', 'email_address': '*****@*****.**', 'password': '******', } # User created in our own tenant with self.user(self.client, **args) as user: assert_that(user, not_(has_key('password'))) assert_that( user, has_entries( uuid=uuid_(), username='******', firstname='Alice', lastname=None, enabled=True, tenant_uuid=self.top_tenant_uuid, emails=contains_inanyorder( has_entries( uuid=uuid_(), address='*****@*****.**', main=True, confirmed=True, )), ), ) # TODO move this assertion to the user tenant tests tenants = self.client.users.get_tenants(user['uuid']) assert_that(tenants['items'], has_items(has_entries(uuid=self.top_tenant_uuid))) wazo_all_users_group = self.client.groups.list( name=f'wazo-all-users-tenant-{self.top_tenant_uuid}', tenant_uuid=self.top_tenant_uuid, )['items'][0] wazo_all_users_group_members = self.client.groups.get_users( wazo_all_users_group['uuid'])['items'] assert_that( wazo_all_users_group_members, has_item(has_entries(uuid=user['uuid'])), ) # User created in subtenant with self.user(self.client, tenant_uuid=isolated['uuid'], **args) as user: assert_that( user, has_entries( uuid=uuid_(), username='******', firstname='Alice', lastname=None, enabled=True, tenant_uuid=isolated['uuid'], emails=contains_inanyorder( has_entries( uuid=uuid_(), address='*****@*****.**', main=True, confirmed=True, )), ), ) # TODO move this assertion to the user tenant tests tenants = self.client.users.get_tenants(user['uuid']) assert_that( tenants, has_entries(items=contains_exactly( has_entries(uuid=isolated['uuid'])), total=1), ) args = { 'uuid': 'fcf9724a-15aa-4dc5-af3c-a9acdb6a2ab9', 'username': '******', 'email_address': '*****@*****.**', } with self.user(self.client, **args) as user: assert_http_error(409, self.client.users.new, **args) assert_http_error(400, self.client.users.new, username='******' * 257) with self.user(self.client, username='******' * 256) as user: assert_that(user, has_entries(username='******' * 256)) # User creation with no email address with self.user(self.client, username='******') as user: assert_that(user, has_entries(username='******', emails=empty())) args = {'username': '******', 'email_address': None} with self.user(self.client, **args) as user: assert_that(user, has_entries(emails=empty())) user_args = { 'username': '******', 'password': '******', 'enabled': False } with self.user(self.client, **user_args) as user: assert_that(user, has_entries(enabled=False)) user_client = self.make_auth_client('foobar', 'foobaz') assert_http_error(401, user_client.token.new, 'wazo_user')
def then_server_has_uuid(context): infos = context.confd_client.infos.get() assert_that(infos, has_entries(uuid=uuid_()))