class DirectoryTopicFilterTest(TestCase):
def setUp(self):
self.directory = DirectoryPageFactory()
# set up topics
pf = TopicFactory(title='Press Freedom')
irs = TopicFactory(title='IRS')
pf.save()
irs.save()
# set up instances that are children of the directory and have those topics
self.pf_instance = DirectoryEntryFactory(parent=self.directory)
self.pf_instance.topics.add(pf)
self.pf_instance.save()
self.irs_instance = DirectoryEntryFactory(parent=self.directory)
self.irs_instance.topics.add(irs)
self.irs_instance.save()
self.topic_filter = {'topics': pf}
def test_topic_filtered_for_is_in_queryset(self):
filtered_instances = self.directory.get_instances(
filters=self.topic_filter)
self.assertIn(self.pf_instance, filtered_instances)
def test_topic_not_filtered_for_is_not_in_queryset(self):
filtered_instances = self.directory.get_instances(
filters=self.topic_filter)
self.assertNotIn(self.irs_instance, filtered_instances)
def handle(self, *args, **options):
number_of_instances = options['number_of_instances']
home_page = HomePage.objects.get(slug='home')
directory = DirectoryPage.objects.first()
if not directory:
directory = DirectoryPageFactory(parent=home_page, title="Directory")
directory.save()
for i in range(number_of_instances):
instance = DirectoryEntryFactory(parent=directory)
if i % 3 == 0:
scan = ScanResultFactory(
securedrop=instance,
landing_page_url=instance.landing_page_url,
no_failures=True,
)
elif i % 3 == 1:
scan = ScanResultFactory(
securedrop=instance,
landing_page_url=instance.landing_page_url,
severe_warning=True,
)
else:
scan = ScanResultFactory(
securedrop=instance,
landing_page_url=instance.landing_page_url,
moderate_warning=True,
)
scan.save()
instance.save()
class DirectoryCountryFilterTest(TestCase):
def setUp(self):
self.directory = DirectoryPageFactory()
# set up countries
mexico = CountryFactory(title='Mexico')
azerbaijan = CountryFactory(title='Azerbaijan')
mexico.save()
azerbaijan.save()
# set up instances that are children of the directory and have those countries
self.mexico_instance = DirectoryEntryFactory(parent=self.directory)
self.mexico_instance.countries.add(mexico)
self.mexico_instance.save()
self.azerbaijan_instance = DirectoryEntryFactory(parent=self.directory)
self.azerbaijan_instance.countries.add(azerbaijan)
self.azerbaijan_instance.save()
self.country_filter = {'countries': mexico}
def test_country_filtered_for_is_in_queryset(self):
filtered_instances = self.directory.get_instances(
filters=self.country_filter)
self.assertIn(self.mexico_instance, filtered_instances)
def test_country_not_filtered_for_is_not_in_queryset(self):
filtered_instances = self.directory.get_instances(
filters=self.country_filter)
self.assertNotIn(self.azerbaijan_instance, filtered_instances)
def setUp(self):
self.directory = DirectoryPageFactory()
self.best_instance = DirectoryEntryFactory(title="Best Instansce",
parent=self.directory)
self.worst_instance = DirectoryEntryFactory(title="Worst Instance",
parent=self.directory)
self.search_filter = {'title__icontains': 'best'}
class DirectoryLanguageFilterTest(TestCase):
def setUp(self):
self.directory = DirectoryPageFactory()
# set up languages
spanish = LanguageFactory(title='Spanish')
chinese = LanguageFactory(title='Chinese')
spanish.save()
chinese.save()
# set up instances that are children of the directory and have those languages
self.spanish_instance = DirectoryEntryFactory(parent=self.directory)
self.spanish_instance.languages.add(spanish)
self.spanish_instance.save()
self.chinese_instance = DirectoryEntryFactory(parent=self.directory)
self.chinese_instance.languages.add(chinese)
self.chinese_instance.save()
self.lang_filter = {'languages': spanish}
def test_language_filtered_for_is_in_queryset(self):
filtered_instances = self.directory.get_instances(
filters=self.lang_filter)
self.assertIn(self.spanish_instance, filtered_instances)
def test_langauge_not_filtered_for_is_not_in_queryset(self):
filtered_instances = self.directory.get_instances(
filters=self.lang_filter)
self.assertNotIn(self.chinese_instance, filtered_instances)
def setUp(self):
self.title = 'Awesome'
self.body = 'Cool'
self.source_warning = 'Alert'
self.directory = DirectoryPageFactory(
title=self.title,
body=RichText(self.body),
source_warning=self.source_warning)
self.search_content = self.directory.get_search_content()
class DirectoryMultipleFiltersTest(TestCase):
def setUp(self):
self.directory = DirectoryPageFactory()
# set up languages
spanish = LanguageFactory(title='Spanish')
chinese = LanguageFactory(title='Chinese')
spanish.save()
chinese.save()
# set up countries
mexico = CountryFactory(title='Mexico')
azerbaijan = CountryFactory(title='Azerbaijan')
mexico.save()
azerbaijan.save()
# set up topics
pf = TopicFactory(title='Press Freedom')
irs = TopicFactory(title='IRS')
pf.save()
irs.save()
# set up instances that are children of the directory and have multiple categories
self.sp_mx_instance = DirectoryEntryFactory(parent=self.directory)
self.sp_mx_instance.languages.add(spanish)
self.sp_mx_instance.countries.add(mexico)
self.sp_mx_instance.save()
self.az_pf_instance = DirectoryEntryFactory(parent=self.directory)
self.az_pf_instance.countries.add(azerbaijan)
self.az_pf_instance.topics.add(pf)
self.az_pf_instance.save()
self.other_instance = DirectoryEntryFactory(parent=self.directory)
self.other_instance.languages.add(spanish)
self.other_instance.topics.add(pf)
self.other_instance.save()
# filters
self.lang_country_filter = {
'languages': spanish,
'countries': mexico
}
self.country_topic_filter = {
'countries': azerbaijan,
'topics': pf
}
def test_country_and_language_filter(self):
filtered_instances = self.directory.get_instances(filters=self.lang_country_filter)
self.assertIn(self.sp_mx_instance, filtered_instances)
self.assertNotIn(self.other_instance, filtered_instances)
def test_country_and_topic_filter(self):
filtered_instances = self.directory.get_instances(filters=self.country_topic_filter)
self.assertIn(self.az_pf_instance, filtered_instances)
self.assertNotIn(self.other_instance, filtered_instances)
class DirectoryFilterTest(TestCase):
def setUp(self):
self.directory = DirectoryPageFactory()
self.child = DirectoryEntryFactory(parent=self.directory)
self.not_child = DirectoryEntryFactory(parent=None)
def test_directory_returns_its_children(self):
filtered_instances = self.directory.get_instances()
self.assertIn(self.child, filtered_instances)
def test_directory_does_not_return_instances_that_are_not_children(self):
filtered_instances = self.directory.get_instances()
self.assertNotIn(self.not_child, filtered_instances)
def setUpTestData(cls):
turn_on_instance_management()
turn_on_instance_scanning()
cls.site = Site.objects.get()
cls.directory = DirectoryPageFactory(parent=cls.site.root_page, )
User = get_user_model()
cls.email = '*****@*****.**'
cls.password = '******'
cls.user = User.objects.create_user(username='******',
password=cls.password,
email=cls.email,
is_active=True)
cls.recipient_group = Group.objects.create(name='Recipient group')
EmailAddress.objects.create(user=cls.user,
email=cls.email,
verified=True)
cls.device = TOTPDevice.objects.create(
user=cls.user,
confirmed=True,
key='2a2bbba1092ffdd25a328ad1a0a5f5d61d7aacc4',
step=30,
t0=int(time() - (30 * 3)),
digits=6,
tolerance=0,
drift=0,
)
def setUp(self):
self.directory = DirectoryPageFactory()
# set up languages
spanish = LanguageFactory(title='Spanish')
chinese = LanguageFactory(title='Chinese')
spanish.save()
chinese.save()
# set up instances that are children of the directory and have those languages
self.spanish_instance = DirectoryEntryFactory(parent=self.directory)
self.spanish_instance.languages.add(spanish)
self.spanish_instance.save()
self.chinese_instance = DirectoryEntryFactory(parent=self.directory)
self.chinese_instance.languages.add(chinese)
self.chinese_instance.save()
self.lang_filter = {'languages': spanish}
def setUp(self):
self.directory = DirectoryPageFactory()
# set up countries
mexico = CountryFactory(title='Mexico')
azerbaijan = CountryFactory(title='Azerbaijan')
mexico.save()
azerbaijan.save()
# set up instances that are children of the directory and have those countries
self.mexico_instance = DirectoryEntryFactory(parent=self.directory)
self.mexico_instance.countries.add(mexico)
self.mexico_instance.save()
self.azerbaijan_instance = DirectoryEntryFactory(parent=self.directory)
self.azerbaijan_instance.countries.add(azerbaijan)
self.azerbaijan_instance.save()
self.country_filter = {'countries': mexico}
def setUp(self):
self.directory = DirectoryPageFactory()
# set up topics
pf = TopicFactory(title='Press Freedom')
irs = TopicFactory(title='IRS')
pf.save()
irs.save()
# set up instances that are children of the directory and have those topics
self.pf_instance = DirectoryEntryFactory(parent=self.directory)
self.pf_instance.topics.add(pf)
self.pf_instance.save()
self.irs_instance = DirectoryEntryFactory(parent=self.directory)
self.irs_instance.topics.add(irs)
self.irs_instance.save()
self.topic_filter = {'topics': pf}
def setUpTestData(cls):
turn_on_instance_management()
turn_on_instance_scanning()
cls.directory = DirectoryPageFactory(
parent=Site.objects.get().root_page,
scanner_form_text='Scanner form',
org_details_form_text='Org form text')
class DirectorySearchFilterTest(TestCase):
def setUp(self):
self.directory = DirectoryPageFactory()
self.best_instance = DirectoryEntryFactory(title="Best Instansce",
parent=self.directory)
self.worst_instance = DirectoryEntryFactory(title="Worst Instance",
parent=self.directory)
self.search_filter = {'title__icontains': 'best'}
def test_title_searched_is_in_queryset(self):
filtered_instances = self.directory.get_instances(
filters=self.search_filter)
self.assertIn(self.best_instance, filtered_instances)
def test_title_not_searched_is_not_in_queryset(self):
filtered_instances = self.directory.get_instances(
filters=self.search_filter)
self.assertNotIn(self.worst_instance, filtered_instances)
class FiltersFromQueryDictTest(TestCase):
def setUp(self):
self.directory = DirectoryPageFactory()
def test_correct_search_term_returned_from_querydict(self):
search_term = "Amet"
querydict = QueryDict('search={}'.format(search_term))
filters = self.directory.filters_from_querydict(querydict)
self.assertEqual(filters['title__icontains'], search_term)
def test_correct_language_returned_from_querydict(self):
georgian = LanguageFactory(title="Georgian")
georgian.save()
querydict = QueryDict('language={}'.format(georgian.id))
filters = self.directory.filters_from_querydict(querydict)
self.assertEqual(filters['languages'], georgian)
def test_correct_country_returned_from_querydict(self):
honduras = CountryFactory(title="Honduras")
honduras.save()
querydict = QueryDict('country={}'.format(honduras.id))
filters = self.directory.filters_from_querydict(querydict)
self.assertEqual(filters['countries'], honduras)
def test_correct_topic_returned_from_querydict(self):
sports = TopicFactory(title="sports")
sports.save()
querydict = QueryDict('topic={}'.format(sports.id))
filters = self.directory.filters_from_querydict(querydict)
self.assertEqual(filters['topics'], sports)
def test_non_int_id_does_not_break_filters(self):
querydict = QueryDict('topic=foo')
filters = self.directory.filters_from_querydict(querydict)
self.assertEqual({}, filters)
def test_invalid_id_does_not_break_filters(self):
querydict = QueryDict('language=100000')
filters = self.directory.filters_from_querydict(querydict)
self.assertEqual({}, filters)
def test_multiple_filters_returned_from_querydict(self):
search_term = "Amet"
afrikaans = LanguageFactory(title="Afrikaans")
afrikaans.save()
thailand = CountryFactory(title="Country")
thailand.save()
scotus = TopicFactory(title="SCOTUS")
scotus.save()
querydict = QueryDict(
'search={}&language={}&topic={}&country={}'.format(
search_term, afrikaans.id, scotus.id, thailand.id))
filters = self.directory.filters_from_querydict(querydict)
self.assertEqual(filters['title__icontains'], search_term)
self.assertEqual(filters['topics'], scotus)
self.assertEqual(filters['countries'], thailand)
self.assertEqual(filters['languages'], afrikaans)
def handle(self, *args, **options):
if options['delete']:
Menu.objects.filter(slug='main').delete()
if not Menu.objects.filter(slug='main').exists():
main = Menu.objects.create(name='Main Menu', slug='main')
home_page = HomePage.objects.get(slug='home')
if BlogIndexPage.objects.first():
blog_index_page = BlogIndexPage.objects.first()
else:
blog_index_page = BlogIndexPageFactory(parent=home_page,
title="News")
if DirectoryPage.objects.first():
directory = DirectoryPage.objects.first()
else:
directory = DirectoryPageFactory(parent=home_page,
title="Directory")
if MarketingIndexPage.objects.first():
marketing = MarketingIndexPage.objects.first()
else:
marketing = MarketingPageFactory(parent=home_page,
title="Features")
MenuItem.objects.bulk_create([
MenuItem(text='Overview',
link_page=marketing,
menu=main,
sort_order=1),
MenuItem(text='News',
link_page=blog_index_page,
menu=main,
sort_order=2),
MenuItem(text='Instance Directory',
link_page=directory,
menu=main,
sort_order=3),
MenuItem(
text='Contribute',
link_url='#',
menu=main,
sort_order=4,
),
MenuItem(
text='Support',
link_url='#',
menu=main,
sort_order=5,
),
])
def setUp(self):
site = Site.objects.get()
self.entry = DirectoryEntryFactory(parent=DirectoryPageFactory(
parent=site.root_page))
self.result = ScanResultFactory(
securedrop=self.entry,
landing_page_url=self.entry.landing_page_url,
moderate_warning=True,
)
self.result.save()
self.entry.save()
self.client = Client()
def setUp(self):
User = get_user_model()
self.client = Client()
self.username = "******"
self.email = "*****@*****.**"
self.password = "******"
self.user = User.objects.create_user(username=self.username, email=self.email, password=self.password, is_active=True)
self.site = Site.objects.get()
self.directory = DirectoryPageFactory(
parent=self.site.root_page,
)
self.unowned_sd_page = DirectoryEntryFactory()
self.unowned_sd_page.save()
self.user_owned_sd_page = DirectoryEntryFactory()
self.user_owned_sd_page.save()
SecuredropOwner(owner=self.user, page=self.user_owned_sd_page).save()
# Create a verified email address object for this user via allauth
EmailAddress.objects.create(user=self.user, email=self.email, verified=True)
# Create a device with pre-determined parameters to allow 2FA
# token verification. Numbers copied from django_otp unit
# tests.
device = TOTPDevice.objects.create(
user=self.user,
confirmed=True,
key='2a2bbba1092ffdd25a328ad1a0a5f5d61d7aacc4',
step=30,
t0=int(time() - (30 * 3)),
digits=6,
tolerance=0,
drift=0,
)
self.client.post(
reverse('account_login'),
{'login': self.email, 'password': self.password},
)
self.client.post(
reverse('two-factor-authenticate'),
# The token below corresponds to the parameters on the
# device just created.
{'otp_device': device.id, 'otp_token': '154567'},
)
def setUp(self):
User = get_user_model()
self.client = Client()
self.username = "******"
self.email = "*****@*****.**"
self.password = "******"
self.user = User.objects.create_user(username=self.username, email=self.email, password=self.password, is_active=True)
self.user.save()
# Create a verified email address object for this user via allauth
EmailAddress.objects.create(user=self.user, email=self.email, verified=True)
# Setup pages. Site is needed for valid urls.
site = Site.objects.get()
directory = DirectoryPageFactory(parent=site.root_page)
self.unowned_sd_page = DirectoryEntryFactory(live=True, parent=directory)
self.unowned_sd_page.save()
self.user_owned_sd_page = DirectoryEntryFactory(live=True, parent=directory)
self.user_owned_sd_page.save()
SecuredropOwner(owner=self.user, page=self.user_owned_sd_page).save()
class TestDirectoryPage(TestCase):
def setUp(self):
self.title = 'Awesome'
self.body = 'Cool'
self.source_warning = 'Alert'
self.directory = DirectoryPageFactory(
title=self.title,
body=RichText(self.body),
source_warning=self.source_warning)
self.search_content = self.directory.get_search_content()
def test_get_search_content_indexes_title(self):
self.assertIn(self.title, self.search_content.text)
def test_get_search_content_indexes_body(self):
self.assertIn(self.body, self.search_content.text)
def test_get_search_content_indexes_source_warning(self):
self.assertIn(self.source_warning, self.search_content.text)
def setUpTestData(self):
site = Site.objects.get(is_default_site=True)
self.directory_settings = DirectorySettings.for_site(site)
self.directory = DirectoryPageFactory(parent=site.root_page)
self.securedrop_page = DirectoryEntryFactory(parent=self.directory)
self.result = ScanResultFactory(securedrop=self.securedrop_page)
def setUp(self):
site = Site.objects.get()
self.entry = DirectoryEntryFactory(parent=DirectoryPageFactory(
parent=site.root_page))
def setUpTestData(cls):
cls.directory = DirectoryPageFactory()
cls.securedrop_page = DirectoryEntryFactory(parent=cls.directory)
def setUp(self):
self.directory = DirectoryPageFactory()
self.child = DirectoryEntryFactory(parent=self.directory)
self.not_child = DirectoryEntryFactory(parent=None)
class DirectorySettingsTestCase(TestCase):
@classmethod
def setUpTestData(self):
site = Site.objects.get(is_default_site=True)
self.directory_settings = DirectorySettings.for_site(site)
self.directory = DirectoryPageFactory(parent=site.root_page)
self.securedrop_page = DirectoryEntryFactory(parent=self.directory)
self.result = ScanResultFactory(securedrop=self.securedrop_page)
def test_scan_disabled_hides_directory_scan_results(self):
self.directory_settings.show_scan_results = False
self.directory_settings.save()
response = self.client.get(self.directory.url)
soup = BeautifulSoup(response.content, 'html.parser')
grades = soup.find_all(class_='instance-table__grade-column')
self.assertEqual(len(grades), 0)
def test_scan_enabled_shows_directory_scan_results(self):
self.directory_settings.show_scan_results = True
self.directory_settings.save()
response = self.client.get(self.directory.url)
soup = BeautifulSoup(response.content, 'html.parser')
grades = soup.find_all(class_='instance-table__grade-column')
self.assertEqual(len(grades), 1)
def test_scan_disabled_hides_detail_scan_results(self):
self.directory_settings.show_scan_results = False
self.directory_settings.save()
response = self.client.get(self.securedrop_page.url)
soup = BeautifulSoup(response.content, 'html.parser')
grade = soup.find_all(class_='security_grade')
result = soup.find_all(class_='scan-result')
self.assertEqual(len(grade), 0)
self.assertEqual(len(result), 0)
def test_scan_enabled_shows_detail_scan_results(self):
self.directory_settings.show_scan_results = True
self.directory_settings.save()
response = self.client.get(self.securedrop_page.url)
soup = BeautifulSoup(response.content, 'html.parser')
grade = soup.find_all(class_='security_grade')
result = soup.find_all(class_='scan-result')
self.assertEqual(len(grade), 1)
self.assertEqual(len(result), 1)
def test_management_disabled_hides_call_to_action(self):
self.directory_settings.allow_directory_management = False
self.directory_settings.save()
# We add a trailing `?` to account for the optional trailing slash
scan_url_re = '{}{}?'.format(
self.directory.url, self.directory.reverse_subpage('scan_view'))
response = self.client.get(self.directory.url)
soup = BeautifulSoup(response.content, 'html.parser')
scan_links = soup.find_all(href=re.compile(scan_url_re))
self.assertEqual(len(scan_links), 0)
def test_management_enabled_shows_call_to_action(self):
self.directory_settings.allow_directory_management = True
self.directory_settings.save()
# We add a trailing `?` to account for the optional trailing slash
scan_url_re = '{}{}?'.format(
self.directory.url, self.directory.reverse_subpage('scan_view'))
response = self.client.get(self.directory.url)
soup = BeautifulSoup(response.content, 'html.parser')
scan_links = soup.find_all(href=re.compile(scan_url_re))
self.assertTrue(len(scan_links) > 0)
def test_management_enabled_shows_footer_login(self):
self.directory_settings.allow_directory_management = True
self.directory_settings.save()
response = self.client.get(self.directory.url)
soup = BeautifulSoup(response.content, 'html.parser')
login_links = soup.find_all(class_='footer-main__admin-link',
href=reverse('account_login'))
self.assertTrue(len(login_links) > 0)
def test_management_disabled_hides_footer_login(self):
self.directory_settings.allow_directory_management = False
self.directory_settings.save()
response = self.client.get(self.directory.url)
soup = BeautifulSoup(response.content, 'html.parser')
login_links = soup.find_all(class_='footer-main__admin-link',
href=reverse('account_login'))
self.assertEqual(len(login_links), 0)
def test_management_disabled_causes_404s(self):
"""
Test that all the relevant paths return 404s is directory management is
disabled. A test for when directory management is enabled is not
included here, since the tests for proper behavior there is included
in the apps that define those views.
"""
self.directory_settings.allow_directory_management = False
self.directory_settings.save()
self.assertEqual(
self.client.get(reverse('dashboard')).status_code, 404)
self.assertEqual(
self.client.get(reverse('securedroppage_add')).status_code, 404)
self.assertEqual(
self.client.get(
reverse('securedroppage_edit',
args=[self.securedrop_page.slug])).status_code, 404)
self.assertEqual(
self.client.get('{}{}'.format(
self.directory.url,
self.directory.reverse_subpage('scan_view'))).status_code, 404)
def setUp(self):
self.directory = DirectoryPageFactory()
