def test_search_by_email_private_profile(self):
"""Testing searching by e-mail address with private profiles"""
user = User.objects.get(username='******')
profile = user.get_profile()
profile.is_private = True
profile.save(update_fields=('is_private',))
reindex_search()
rsp = self.search('@example.com')
self.assertEqual(rsp.context['hits_returned'], 3)
actual_results = {
key.id
for key in rsp.context['page_obj']
}
expected_results = {
'auth.user.1',
'auth.user.3',
'auth.user.4',
}
self.assertEqual(expected_results, actual_results)
def test_review_requests_with_private_repository_as_submitter(self):
"""Testing search with private review requests without access to
a private repository as the submitter
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
repository = self.create_repository(public=False)
repository.users.add(user)
review_request = self.create_review_request(repository=repository,
submitter=user,
publish=True)
self.assertTrue(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search(review_request.summary)
context = response.context
self.assertEqual(context['hits_returned'], 1)
results = context['object_list']
self.assertEqual(results[0].content_type(), 'reviews.reviewrequest')
self.assertEqual(results[0].summary, review_request.summary)
def test_review_requests_with_private_repo_access_through_group(self):
"""Testing search with private review requests with access to
private repositories through groups
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
group = self.create_review_group(invite_only=True)
group.users.add(user)
repository = self.create_repository(public=False)
repository.review_groups.add(group)
review_request = self.create_review_request(repository=repository,
publish=True)
self.assertTrue(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search(review_request.summary)
context = response.context
self.assertEqual(context['hits_returned'], 1)
results = context['object_list']
self.assertEqual(results[0].content_type(), 'reviews.reviewrequest')
self.assertEqual(results[0].summary, review_request.summary)
def test_on_the_fly_indexing_profile(self):
"""Testing on-the-fly indexing for user profiles"""
reindex_search()
siteconfig = SiteConfiguration.objects.get_current()
siteconfig.set('search_on_the_fly_indexing', True)
siteconfig.save()
try:
self.spy_on(signal_processor.handle_save)
user = User.objects.get(username='******')
profile = user.get_profile()
profile.is_private = True
profile.save(update_fields=('is_private',))
rsp = self.search('doc')
finally:
siteconfig = SiteConfiguration.objects.get_current()
siteconfig.set('search_on_the_fly_indexing', False)
siteconfig.save()
self.assertEqual(len(signal_processor.handle_save.spy.calls), 1)
self.assertEqual(rsp.context['hits_returned'], 1)
result = rsp.context['result']
self.assertEqual(result.groups, '')
self.assertEqual(result.url, '/users/doc/')
self.assertEqual(result.username, 'doc')
self.assertEqual(result.full_name, '')
def test_search_by_name_private_profile(self):
"""Testing searching by first/last name with private profiles"""
user = User.objects.get(username='******')
user.first_name = 'Doctor'
user.save()
profile = user.get_profile()
profile.is_private = True
profile.save(update_fields=('is_private',))
self.create_review_request(submitter=user, publish=True)
reindex_search()
rsp = self.search('Doctor')
self.assertEqual(rsp.context['hits_returned'], 0)
rsp = self.search('Dwarf')
self.assertEqual(rsp.context['hits_returned'], 2)
actual_results = {
key.id
for key in rsp.context['page_obj']
}
expected_results = {
'auth.user.3',
'auth.user.4',
}
self.assertEqual(expected_results, actual_results)
def test_search_by_full_name_private_profile(self):
"""Testing searching by full name for users with private profiles"""
user = User.objects.get(username='******')
profile = user.get_profile()
profile.is_private = True
profile.save(update_fields=('is_private',))
self.create_review_request(submitter=user, publish=True)
reindex_search()
rsp = self.search('Doc Dwarf')
self.assertEqual(rsp.context['hits_returned'], 0)
def test_filter_users(self):
"""Testing search with filtering for review requests"""
# We already have doc. Now let's create a review request.
self.create_review_request(submitter='doc', publish=True)
reindex_search()
# Perform the search.
response = self.search('doc', filter_by='users')
context = response.context
self.assertEqual(context['hits_returned'], 1)
results = context['object_list']
self.assertEqual(results[0].content_type(), 'auth.user')
self.assertEqual(results[0].username, 'doc')
def test_review_requests_without_private_repo_access(self):
"""Testing search with private review requests without access to
private repositories
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
repository = self.create_repository(public=False)
review_request = self.create_review_request(repository=repository,
publish=True)
self.assertFalse(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search(review_request.summary)
context = response.context
self.assertEqual(context['hits_returned'], 0)
def test_get_user_public_profile_indexed(self):
"""Testing the GET <URL> API with the search index enabled and
on-the-fly indexing enabled for a user with a public profile
"""
with search_enabled(on_the_fly_indexing=True):
reindex_search()
rsp = self.api_get(get_search_url(),
query={'q': 'doc'},
expected_mimetype=search_mimetype)
search_results = rsp['search']
self.assertEqual(len(search_results['groups']), 0)
self.assertEqual(len(search_results['review_requests']), 0)
self.assertEqual(len(search_results['users']), 1)
item_rsp = search_results['users'][0]
self.assertIn('fullname', item_rsp)
def test_search_all(self):
"""Testing search with review requests and users"""
# We already have doc. Now let's create a review request.
review_request = self.create_review_request(submitter='doc',
publish=True)
reindex_search()
# Perform the search.
response = self.search('doc')
context = response.context
self.assertEqual(context['hits_returned'], 2)
results = context['object_list']
self.assertEqual(results[0].content_type(), 'auth.user')
self.assertEqual(results[0].username, 'doc')
self.assertEqual(results[1].content_type(), 'reviews.reviewrequest')
self.assertEqual(results[1].summary, review_request.summary)
def test_on_the_fly_indexing_review_requests(self):
"""Testing on-the-fly indexing for review requests"""
reindex_search()
siteconfig = SiteConfiguration.objects.get_current()
siteconfig.set('search_on_the_fly_indexing', True)
siteconfig.save()
group = self.create_review_group()
invite_only_group = self.create_review_group(name='invite-only-group',
invite_only=True)
grumpy = User.objects.get(username='******')
try:
self.spy_on(signal_processor.handle_save)
review_request = self.create_review_request(summary='foo',
publish=True)
self.assertTrue(signal_processor.handle_save.spy.called)
draft = ReviewRequestDraft.create(review_request)
draft.summary = 'Not foo whatsoever'
draft.save()
draft.target_people = [grumpy]
draft.target_groups = [group, invite_only_group]
review_request.publish(review_request.submitter)
rsp = self.search('Not foo')
finally:
siteconfig = SiteConfiguration.objects.get_current()
siteconfig.set('search_on_the_fly_indexing', False)
siteconfig.save()
# There will be one call from each publish.
self.assertEqual(len(signal_processor.handle_save.spy.calls), 2)
self.assertEqual(rsp.context['hits_returned'], 1)
result = rsp.context['result']
self.assertEqual(result.summary, 'Not foo whatsoever')
self.assertEqual(result.target_users, [six.text_type(grumpy.pk)])
self.assertEqual(result.private_target_groups,
[six.text_type(invite_only_group.pk)])
def test_on_the_fly_indexing_users(self):
"""Testing on-the-fly indexing for users"""
reindex_search()
siteconfig = SiteConfiguration.objects.get_current()
siteconfig.set('search_on_the_fly_indexing', True)
siteconfig.save()
u = User.objects.get(username='******')
group = self.create_review_group()
invite_only_group = self.create_review_group(name='invite-only-group',
invite_only=True)
try:
self.spy_on(signal_processor.handle_save)
u.username = '******'
u.first_name = 'Not Doc'
u.last_name = 'Dwarf'
u.save()
u.review_groups = [group, invite_only_group]
invite_only_group.users = [u]
rsp = self.search('not_doc')
finally:
siteconfig = SiteConfiguration.objects.get_current()
siteconfig.set('search_on_the_fly_indexing', False)
siteconfig.save()
# There should be five calls:
# * two from each of the m2m_changed actions post_clear and
# post_add; and
# * and one from User.save().
self.assertEqual(len(signal_processor.handle_save.spy.calls), 5)
self.assertEqual(rsp.context['hits_returned'], 1)
result = rsp.context['result']
self.assertEqual(result.groups, 'test-group')
self.assertEqual(result.url, '/users/not_doc/')
self.assertEqual(result.username, 'not_doc')
self.assertEqual(result.full_name, 'Not Doc Dwarf')
def test_review_requests_without_private_group_access(self):
"""Testing search with private review requests without access to
a private group
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
group = self.create_review_group(invite_only=True)
review_request = self.create_review_request(publish=True)
review_request.target_groups.add(group)
self.assertFalse(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search(review_request.summary)
context = response.context
self.assertEqual(context['hits_returned'], 0)
def test_search_review_request_id(self):
"""Testing search with a review request ID"""
site = Site.objects.get_current()
site.domain = 'testserver'
site.save()
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
review_request = self.create_review_request(publish=True)
self.assertTrue(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search('%d' % review_request.id)
self.assertEqual(response.url,
build_server_url(review_request.get_absolute_url()))
def test_review_requests_without_private_group_access(self):
"""Testing search with private review requests without access to
a private group
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
group = self.create_review_group(invite_only=True)
review_request = self.create_review_request(publish=True)
review_request.target_groups.add(group)
self.assertFalse(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search(review_request.summary)
context = response.context
self.assertEqual(context['hits_returned'], 0)
def test_review_requests_with_private_repository_and_target_people(self):
"""Testing search with private review requests without access to
a private repository and user in target_people
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
repository = self.create_repository(public=False)
review_request = self.create_review_request(repository=repository,
publish=True)
review_request.target_people.add(user)
self.assertFalse(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search(review_request.summary)
context = response.context
self.assertEqual(context['hits_returned'], 0)
def test_search_review_request_id(self):
"""Testing search with a review request ID"""
site = Site.objects.get_current()
site.domain = 'testserver'
site.save()
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
review_request = self.create_review_request(publish=True)
self.assertTrue(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search('%d' % review_request.id)
self.assertEqual(response.url,
build_server_url(review_request.get_absolute_url()))
def test_search_by_email_public_profile(self):
"""Testing searching by e-mail address with public profiles"""
reindex_search()
rsp = self.search('@example.com')
self.assertEqual(rsp.context['hits_returned'], 4)
actual_results = {
key.id
for key in rsp.context['page_obj']
}
expected_results = {
'auth.user.1',
'auth.user.2',
'auth.user.3',
'auth.user.4',
}
self.assertEqual(expected_results, actual_results)
def test_search_by_email_public_profile(self):
"""Testing searching by e-mail address with public profiles"""
reindex_search()
rsp = self.search('@example.com')
self.assertEqual(rsp.context['hits_returned'], 4)
actual_results = {
key.id
for key in rsp.context['page_obj']
}
expected_results = {
'auth.user.1',
'auth.user.2',
'auth.user.3',
'auth.user.4',
}
self.assertEqual(expected_results, actual_results)
def test_get_from_search_index_on_the_fly(self):
"""Testing the GET <URL> API with the search index enabled and
on-the-fly indexing enabled
"""
self.create_review_request(submitter=self.user, public=True)
self.spy_on(resources.review_request.serialize_object)
self.spy_on(resources.user.serialize_object)
with search_enabled(on_the_fly_indexing=True):
reindex_search()
rsp = self.api_get(get_search_url(),
query={'q': self.user.username},
expected_mimetype=search_mimetype)
self.assertEqual(len(rsp['search']['groups']), 0)
self.assertEqual(len(rsp['search']['review_requests']), 1)
self.assertEqual(len(rsp['search']['users']), 1)
self.assertFalse(resources.review_request.serialize_object.spy.called)
self.assertFalse(resources.user.serialize_object.spy.called)
def test_search_numeric_non_id(self):
"""Testing search with a numeric query that is not a review request
ID
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
review_request = self.create_review_request(bugs_closed='123,456',
publish=True)
self.assertTrue(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search('456')
context = response.context
self.assertEqual(context['hits_returned'], 1)
results = context['object_list']
self.assertEqual(results[0].content_type(), 'reviews.reviewrequest')
self.assertEqual(results[0].summary, review_request.summary)
def test_search_numeric_non_id(self):
"""Testing search with a numeric query that is not a review request
ID
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
review_request = self.create_review_request(bugs_closed='123,456',
publish=True)
self.assertTrue(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search('456')
context = response.context
self.assertEqual(context['hits_returned'], 1)
results = context['object_list']
self.assertEqual(results[0].content_type(), 'reviews.reviewrequest')
self.assertEqual(results[0].summary, review_request.summary)
def test_get_from_search_index_on_the_fly(self):
"""Testing the GET <URL> API with the search index enabled and
on-the-fly indexing enabled
"""
self.create_review_request(submitter=self.user, public=True)
self.spy_on(resources.review_request.serialize_object)
self.spy_on(resources.user.serialize_object)
with search_enabled(on_the_fly_indexing=True):
reindex_search()
rsp = self.api_get(get_search_url(),
query={'q': self.user.username},
expected_mimetype=search_mimetype)
self.assertEqual(len(rsp['search']['groups']), 0)
self.assertEqual(len(rsp['search']['review_requests']), 1)
self.assertEqual(len(rsp['search']['users']), 1)
self.assertFalse(resources.review_request.serialize_object.spy.called)
self.assertFalse(resources.user.serialize_object.spy.called)
def test_search_by_email_private_profile(self):
"""Testing searching by e-mail address with private profiles"""
user = User.objects.get(username='******')
profile = user.get_profile()
profile.is_private = True
profile.save()
reindex_search()
rsp = self.search('@example.com')
self.assertEqual(rsp.context['hits_returned'], 3)
actual_results = {key.id for key in rsp.context['page_obj']}
expected_results = {
'auth.user.1',
'auth.user.3',
'auth.user.4',
}
self.assertEqual(expected_results, actual_results)
def test_search_by_name_public_profile(self):
"""Testing searching by first/last name with public profiles"""
user = User.objects.get(username='******')
user.first_name = 'Doctor'
user.save()
self.create_review_request(submitter=user, publish=True)
reindex_search()
rsp = self.search('Doctor')
self.assertEqual(rsp.context['hits_returned'], 2)
actual_results = {
key.id
for key in rsp.context['page_obj']
}
expected_results = {
'auth.user.2',
'reviews.reviewrequest.1',
}
self.assertEqual(expected_results, actual_results)
rsp = self.search('Dwarf')
self.assertEqual(rsp.context['hits_returned'], 4)
actual_results = {
key.id
for key in rsp.context['page_obj']
}
expected_results = {
'auth.user.2',
'auth.user.3',
'auth.user.4',
'reviews.reviewrequest.1',
}
self.assertEqual(expected_results, actual_results)
def test_on_the_fly_indexing_review_requests(self):
"""Testing on-the-fly indexing for review requests"""
reindex_search()
signal_processor = self.signal_processor
group = self.create_review_group()
invite_only_group = self.create_review_group(name='invite-only-group',
invite_only=True)
grumpy = User.objects.get(username='******')
with self.siteconfig_settings({'search_on_the_fly_indexing': True},
reload_settings=False):
self.spy_on(signal_processor.handle_save)
review_request = self.create_review_request(summary='foo',
publish=True)
self.assertTrue(signal_processor.handle_save.spy.called)
draft = ReviewRequestDraft.create(review_request)
draft.summary = 'Not foo whatsoever'
draft.save()
draft.target_people = [grumpy]
draft.target_groups = [group, invite_only_group]
review_request.publish(review_request.submitter)
rsp = self.search('Not foo')
# There will be one call from each publish.
self.assertEqual(len(signal_processor.handle_save.spy.calls), 2)
self.assertEqual(rsp.context['hits_returned'], 1)
result = rsp.context['result']
self.assertEqual(result.summary, 'Not foo whatsoever')
self.assertEqual(result.target_users, [str(grumpy.pk)])
self.assertEqual(result.private_target_groups,
[str(invite_only_group.pk)])
def test_search_by_full_name_public_profile(self):
"""Testing searching by full name for users with public profiles"""
user = User.objects.get(username='******')
self.create_review_request(submitter=user,
publish=True)
reindex_search()
rsp = self.search('Doc Dwarf')
self.assertEqual(rsp.context['hits_returned'], 2)
actual_results = {
key.id
for key in rsp.context['page_obj']
}
expected_results = {
'auth.user.2',
'reviews.reviewrequest.1',
}
self.assertEqual(expected_results, actual_results)
def test_get_private_user_indexed(self):
"""Testing the GET <URL> API with the search index enabled and
on-the-fly indexing enabled for a user with a private profile
"""
profile = Profile.objects.get(user__username='******')
profile.is_private = True
profile.save()
with search_enabled(on_the_fly_indexing=True):
reindex_search()
rsp = self.api_get(get_search_url(),
query={'q': 'doc'},
expected_mimetype=search_mimetype)
search_results = rsp['search']
self.assertEqual(len(search_results['groups']), 0)
self.assertEqual(len(search_results['review_requests']), 0)
self.assertEqual(len(search_results['users']), 1)
profile = Profile.objects.get(user__username='******')
item_rsp = search_results['users'][0]
self.assertNotIn('fullname', item_rsp)
def test_get_private_user_indexed(self):
"""Testing the GET <URL> API with the search index enabled and
on-the-fly indexing enabled for a user with a private profile
"""
profile = Profile.objects.get(user__username='******')
profile.is_private = True
profile.save(update_fields=('is_private',))
with search_enabled(on_the_fly_indexing=True):
reindex_search()
rsp = self.api_get(get_search_url(),
query={'q': 'doc'},
expected_mimetype=search_mimetype)
search_results = rsp['search']
self.assertEqual(len(search_results['groups']), 0)
self.assertEqual(len(search_results['review_requests']), 0)
self.assertEqual(len(search_results['users']), 1)
profile = Profile.objects.get(user__username='******')
item_rsp = search_results['users'][0]
self.assertNotIn('fullname', item_rsp)
def test_review_requests_with_private_group_and_target_people(self):
"""Testing search with private review requests without access to
a private group and user in target_people
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
group = self.create_review_group(invite_only=True)
review_request = self.create_review_request(publish=True)
review_request.target_groups.add(group)
review_request.target_people.add(user)
self.assertTrue(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search(review_request.summary)
context = response.context
self.assertEqual(context['hits_returned'], 1)
results = context['object_list']
self.assertEqual(results[0].content_type(), 'reviews.reviewrequest')
self.assertEqual(results[0].summary, review_request.summary)
def test_review_requests_with_private_repo_access(self):
"""Testing search with private review requests with access to
private repositories
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
repository = self.create_repository(public=False)
repository.users.add(user)
review_request = self.create_review_request(repository=repository,
publish=True)
self.assertTrue(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search(review_request.summary)
context = response.context
self.assertEqual(context['hits_returned'], 1)
results = context['object_list']
self.assertEqual(results[0].content_type(), 'reviews.reviewrequest')
self.assertEqual(results[0].summary, review_request.summary)
def test_review_requests_with_private_group_and_target_people(self):
"""Testing search with private review requests without access to
a private group and user in target_people
"""
self.client.login(username='******', password='******')
user = User.objects.get(username='******')
group = self.create_review_group(invite_only=True)
review_request = self.create_review_request(publish=True)
review_request.target_groups.add(group)
review_request.target_people.add(user)
self.assertTrue(review_request.is_accessible_by(user))
reindex_search()
# Perform the search.
response = self.search(review_request.summary)
context = response.context
self.assertEqual(context['hits_returned'], 1)
results = context['object_list']
self.assertEqual(results[0].content_type(), 'reviews.reviewrequest')
self.assertEqual(results[0].summary, review_request.summary)
