def setUpTestData(cls):
cls.service = services.DefinitionGathering
cls.fake_def_1 = factories.DefinitionFactory(value='l')
cls.fake_def_2 = factories.DefinitionFactory(value='o')
cls.fake_def_3 = factories.DefinitionFactory(value='e')
cls.fake_def_4 = factories.DefinitionFactory(value='d', active=False)
cls.objects = [cls.fake_def_1, cls.fake_def_2, cls.fake_def_3]
def setUpTestData(cls):
cls.client = test.Client()
cls.term = factories.TermFactory(value='fake term')
cls.definition_foo = factories.DefinitionFactory(
uuid='cb8d30f8-b60a-46e8-9cad-f3d5ff28d269',
term=cls.term,
value='foo',
)
cls.definition_bar = factories.DefinitionFactory(
uuid='75484634-4f96-4bc9-8d94-bfe8523ba7cd',
term=cls.term,
value='bar',
)
cls.url = reverse('term-detail', kwargs={'slug': cls.term.slug})
def test_definitions(self):
definition_foo = factories.DefinitionFactory(term=self.term,
value='foo')
definition_bar = factories.DefinitionFactory(term=self.term,
value='bar')
factories.DefinitionFactory(value='qux')
queryset = models.Definition.objects.filter(
pk__in=[definition_foo.pk, definition_bar.pk]
)
self.assertQuerysetEqual(self.term.definitions,
queryset,
ordered=False,
transform=lambda x: x)
def setUpTestData(cls):
cls.client = test.Client()
cls.foo_term = factories.TermFactory(value='foo term')
cls.bar_term = factories.TermFactory(value='bar term')
cls.definition_foo = factories.DefinitionFactory(
uuid='b3ec0487-d422-4d0e-86c0-0b80402fb012',
term=cls.foo_term,
value='foo',
)
cls.definition_bar = factories.DefinitionFactory(
uuid='8ce7d087-b231-4562-b43f-dd27c7af7eba',
term=cls.bar_term,
value='bar',
)
cls.url = reverse('term-search')
def test_has_definition(self):
definition = factories.DefinitionFactory(value='fake definition')
response = self.client.get(reverse('sitemap'))
self.assertEqual(response.status_code, 200)
self.assertContains(response, definition.get_absolute_url())
def test_update_definition_dont_send_an_email(self):
self.client.login(username=self.user.username,
password='******')
self.assertEqual(len(mail.outbox), 0)
definition = factories.DefinitionFactory(
value='fake definition',
user=self.user,
)
self.assertEqual(models.Definition.objects.count(), 1)
self.assertEqual(len(mail.outbox), 1)
url = reverse(
'definition-update',
kwargs={'uuid': definition.uuid}
)
form_data = {'term': 'fake term', 'value': 'modified definition'}
form_data.update(self.management_data)
response = self.client.post(url, form_data, follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(models.Definition.objects.count(), 1)
self.assertEqual(len(mail.outbox), 1)
def test_update_definition__change_term_multiple_defs(self):
other_def = factories.DefinitionFactory(term=self.definition.term)
self.assertEqual(models.Term.objects.count(), 1)
self.assertEqual(models.Definition.objects.count(), 2)
self.assertEqual(
self.definition.uuid,
'869fc83b-2004-428d-9870-9089a8f29f20',
)
self.assertEqual(self.definition.term.value, 'term fake')
self.assertEqual(self.definition.value, 'definition fake')
self.assertEqual(self.definition.user, self.user)
self._login()
form_data = {
'term': 'updated term fake',
'value': 'updated fake definition',
}
form_data.update(self.management_data)
response = self.client.post(self.url, form_data, follow=True)
self.assertEqual(response.status_code, 200)
self.assertEqual(models.Term.objects.count(), 2)
self.assertEqual(models.Definition.objects.count(), 2)
first_term = models.Term.objects.get(value='term fake')
second_term = models.Term.objects.get(value='updated term fake')
self.assertEqual(first_term.definitions.count(), 1)
self.assertEqual(first_term.definitions.first(), other_def)
self.assertEqual(second_term.definitions.count(), 1)
self.assertEqual(second_term.definitions.first(), self.definition)
def setUp(self):
definition = factories.DefinitionFactory(
uuid='13bf0f68-eeb2-4777-a739-6ee5be30bacc',
value='fake_definition',
)
factories.ExampleFactory(definition=definition)
self.client = test.Client()
self.url = reverse('index')
def test_has_link_to_definition_detail(self):
definition = factories.DefinitionFactory(value='fake definition')
response = self.client.get(self.url)
self.assertContains(
response,
f'<a href="{definition.get_absolute_url()}">🔗</a>',
html=True)
def setUp(self):
self.client = test.Client()
self.user = auth_factories.UserFactory()
self.definition = factories.DefinitionFactory(
uuid='869fc83b-2004-428d-9870-9089a8f29f20',
user=self.user,
)
self.url = reverse('definition-disable',
kwargs={'uuid': self.definition.uuid})
def test_has_link_to_term_detail(self):
term = factories.TermFactory(value='my fake term')
factories.DefinitionFactory(term=term, value='fake definition')
response = self.client.get(self.url)
self.assertContains(
response,
f'<a href="{term.get_absolute_url()}">my fake term</a>',
html=True)
def setUpTestData(cls):
cls.client = test.Client()
cls.user = auth_factories.UserFactory()
cls.definition = factories.DefinitionFactory(
uuid='869fc83b-2004-428d-9870-9089a8f29f20',
user=cls.user,
)
cls.url = reverse('definition-disable',
kwargs={'uuid': cls.definition.uuid})
def test_has_link_current_page(self):
factories.DefinitionFactory()
response = self.client.get(self.url)
html_text = ('<a class="page-link" href="#">'
'1'
'<span class="sr-only">(current)</span>'
'</a>')
self.assertContains(response, html_text, html=True)
def test_has_tags(self):
factories.DefinitionFactory(value='fake definition',
tags='first_tag, second_tag')
response = self.client.get(self.url)
tag_html = '<a href="{}" class="badge badge-pill badge-info">{}</a>'
for tag in ('first_tag', 'second_tag'):
email_link = '/tags/{}/definitions/'.format(tag)
self.assertContains(response, tag_html.format(email_link, tag))
def test_has_tags(self):
factories.DefinitionFactory(value='fake definition', tags='tag1, tag3')
response = self.client.get(reverse('sitemap'))
self.assertEqual(response.status_code, 200)
for tag in ('tag1', 'tag3'):
self.assertContains(
response,
reverse('definitions-by-tag', kwargs={'tag_name': tag}))
def setUp(self):
self.client = test.Client()
self.user = auth_factories.UserFactory()
self.term = factories.TermFactory(value='fake term')
self.definition = factories.DefinitionFactory(
uuid='6b4a7a9f-3b8f-494b-8565-f960065802ba',
term=self.term,
value='fake definition',
user=self.user,
)
self.url = self.definition.get_absolute_url()
def setUpTestData(cls):
cls.client = test.Client()
cls.user = auth_factories.UserFactory()
cls.term = factories.TermFactory(value='fake term')
cls.definition = factories.DefinitionFactory(
uuid='6b4a7a9f-3b8f-494b-8565-f960065802ba',
term=cls.term,
value='fake definition',
user=cls.user,
)
cls.url = cls.definition.get_absolute_url()
def test_term_search_form_is_working(self):
foo_term = factories.TermFactory(value='foo term')
bar_term = factories.TermFactory(value='bar term')
factories.DefinitionFactory(term=foo_term, value='foo')
factories.DefinitionFactory(term=bar_term, value='bar')
foo_term_html = '<a href="{}">foo term</a>'.format(
foo_term.get_absolute_url())
bar_term_html = '<a href="{}">bar term</a>'.format(
bar_term.get_absolute_url())
with splinter.Browser('django') as browser:
browser.visit(self.url)
self.assertIn(foo_term_html, browser.html)
self.assertIn(bar_term_html, browser.html)
browser.fill('v', 'f')
browser.find_by_id('form-button').click()
self.assertEqual(browser.url, reverse('term-search'))
self.assertIn(foo_term_html, browser.html)
self.assertNotIn(bar_term_html, browser.html)
def test_has_examples(self):
definition = factories.DefinitionFactory(value='fake definition')
response = self.client.get(self.url)
self.assertNotContains(response, 'fake example')
factories.ExampleFactory(definition=definition, value='fake example')
response = self.client.get(self.url)
self.assertContains(response, 'fake example')
def test_inactive_definitions_does_not_appear(self):
definition = factories.DefinitionFactory(value='fake definition')
response = self.client.get(self.url)
self.assertContains(response, 'fake definition')
definition.active = False
definition.save()
response = self.client.get(self.url)
self.assertNotContains(response, 'fake definition')
def test_has_link_to_next_page(self):
num_items_per_page = views.IndexView.paginate_by
for item in range(num_items_per_page + 1):
factories.DefinitionFactory()
response = self.client.get(self.url)
self.assertContains(response,
'<a class="page-link" href="?page=2">2</a>',
html=True)
self.assertContains(
response,
'<a class="page-link" href="?page=2">Siguiente →</a>',
html=True)
def test_has_link_to_next_page(self):
num_items_per_page = views.TermSearchView.paginate_by
for n, item in enumerate(range(num_items_per_page + 1)):
term = factories.TermFactory(value='a' * (n + 1))
factories.DefinitionFactory(term=term)
url = '{}?{}'.format(self.url, http.urlencode({'v': 'a'}))
response = self.client.get(url)
self.assertContains(response,
'<a class="page-link" href="?page=2">2</a>',
html=True)
self.assertContains(
response,
'<a class="page-link" href="?page=2">Siguiente →</a>',
html=True)
def test_has_link_to_first_page(self):
num_items_per_page = views.IndexView.paginate_by
for item in range(num_items_per_page + 1):
factories.DefinitionFactory()
url = f'{self.url}?page=2'
response = self.client.get(url)
self.assertContains(response,
'<a class="page-link" href="?page=1">1</a>',
html=True)
self.assertContains(
response,
'<a class="page-link" href="?page=1">← Anterior</a>',
html=True)
def test_has_link_to_first_page(self):
num_items_per_page = views.IndexView.paginate_by
for n, item in enumerate(range(num_items_per_page + 1)):
term = factories.TermFactory(value='a' * (n + 1))
factories.DefinitionFactory(term=term)
url = '{}?{}'.format(self.url, http.urlencode({'v': 'a', 'page': 2}))
response = self.client.get(url)
response = self.client.get(url)
self.assertContains(response,
'<a class="page-link" href="?page=1">1</a>',
html=True)
self.assertContains(
response,
'<a class="page-link" href="?page=1">← Anterior</a>',
html=True)
def test_recaptcha_failed__already_existing_term(self,
recaptcha_clean_mock):
def _validation_error_side_effect(values):
raise exceptions.ValidationError(
'Connection to reCaptcha server failed',
code='connection_failed')
recaptcha_clean_mock.side_effect = _validation_error_side_effect
self.term = factories.TermFactory(value='fake term')
self.definition = factories.DefinitionFactory(
uuid='6b4a7a9f-3b8f-494b-8565-f960065802ba',
term=self.term,
value='fake definition 1',
user=self.user,
)
self.assertEqual(models.Term.objects.count(), 1)
self.assertEqual(models.Definition.objects.count(), 1)
form_data = {'term': 'fake term', 'value': 'fake definition 2'}
form_data.update(self.management_data)
response = self.client.post(self.url, form_data, follow=True)
self.assertEqual(response.status_code, 200)
recaptcha_clean_mock.assert_called_once()
self.assertEqual(models.Term.objects.count(), 1)
self.assertEqual(models.Term.all_objects.count(), 1)
self.assertEqual(models.Definition.objects.count(), 1)
self.assertEqual(
models.Term.all_objects.first().value,
'fake term',
)
self.assertEqual(
models.Definition.all_objects.first().value,
'fake definition 1',
)
def setUpTestData(cls):
cls.client = test.Client()
cls.user = auth_factories.UserFactory()
cls.definition = factories.DefinitionFactory(
uuid='869fc83b-2004-428d-9870-9089a8f29f20',
user=cls.user,
)
cls.url = reverse('definition-update',
kwargs={'uuid': cls.definition.uuid})
cls.management_data = {
"example_set-TOTAL_FORMS": "2",
"example_set-INITIAL_FORMS": "0",
"example_set-MIN_NUM_FORMS": "0",
"example_set-MAX_NUM_FORMS": "5",
"example_set-0-value": "",
"example_set-0-id": "",
"example_set-0-definition": "",
"example_set-1-value": "",
"example_set-1-id": "",
"example_set-1-definition": ""
}
def setUp(self):
self.definition = factories.DefinitionFactory(
value='my fake definition')
def setUpTestData(cls):
factories.DefinitionFactory(tags='a fake tag, othertag')
cls.client = test.Client()
cls.url = reverse('tag-list')
def setUp(self):
self.service = services.DefinitionGathering
self.fake_def_1 = factories.DefinitionFactory(value='l')
self.fake_def_2 = factories.DefinitionFactory(value='o')
self.fake_def_3 = factories.DefinitionFactory(value='e')
self.objects = [self.fake_def_1, self.fake_def_2, self.fake_def_3]
