def test_non_unique_slug_if_different_sport(self):
sport = SportFactory.create(name='Basketball')
sport2 = SportFactory.create(name='Football')
term = TermFactory.create(text='Rebound', sport=sport, user=self.user)
term2 = TermFactory.create(text='Rebound',
sport=sport2,
user=self.user)
self.assertEqual(term.slug, term2.slug)
def test_paginator_only_holds_terms_from_sport(self):
another_sport = SportFactory.create(name='Another Sport')
TermFactory.create(sport=another_sport, text='Term in another sport')
response = self.client.get(
reverse('sport_index', kwargs={'sport_slug': self.sport.slug}))
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context['paginator'].count, 100)
# verify other term exists (total num of terms should = 101)
terms = Term.objects.all()
self.assertEqual(terms.count(), 101)
def setUpTestData(cls):
# Create a sport, a term belonging to that sport & 10 definitions for that term
sport = SportFactory.create(name='Sport')
cls.term = TermFactory.create(sport=sport, text='Term for sport')
cls.user = UserFactory.create(username='******')
DefinitionFactory.create_batch(10, term=cls.term, user=cls.user)
def setUpTestData(cls):
u = UserFactory.create()
su = UserFactory.create(is_staff=True)
s = SportFactory.create()
t = TermFactory.create(user=u, sport=s)
SuggestedTermFactory.create(user=u, sport=s)
CategoryFactory.create(sport=s)
d = DefinitionFactory.create(user=u, term=t)
VoteFactory.create(user=u, definition=d)
def test_valid_internal_link_different_sport_no_label(self):
different_sport = SportFactory.create(name='Different sport')
term = TermFactory.create(sport=different_sport, text='Text')
result = custom_urlize(f'[[{term.slug}]]', different_sport)
self.assertEqual(
result,
f'<a href="{term.get_absolute_url()}" class="term-link-in-definition">{term.text.lower()}</a>'
)
def test_num_approved_definitions(self):
term = TermFactory.create(
text='term to test number of approved definitions',
sport=self.sport,
user=self.user)
# these created definitions are approved by default
DefinitionFactory.create(term=term, user=self.user)
DefinitionFactory.create(term=term, user=self.user)
# this definition has to be disapproved
DefinitionFactory.create(term=term, user=self.user, approvedFl=False)
self.assertEqual(term.num_approved_definitions(), 2)
def setUpTestData(cls):
# Create 100 Terms in a single belonging to a single sport
num_terms = 100
cls.sport = SportFactory.create()
TermFactory.create_batch(num_terms, sport=cls.sport)
def test_unique_slug_if_same_sport(self):
sport = SportFactory.create(name='Basketball')
term = TermFactory.create(text='Rebound', sport=sport, user=self.user)
term2 = TermFactory.create(text='rebound', sport=sport, user=self.user)
self.assertNotEqual(term.slug, term2.slug)
def test_get_absolute_url(self):
sport = SportFactory.create(name='Football')
term = TermFactory.create(text='False 9', sport=sport, user=self.user)
self.assertEquals(term.get_absolute_url(), '/term/football/false-9')
def setUpTestData(cls):
cls.user = UserFactory.create()
cls.sport = SportFactory.create()
cls.term = TermFactory.create()
cls.definition = DefinitionFactory.create()
cls.vote = VoteFactory.create()
def setUpTestData(cls):
TermFactory.create_batch(15)
def setUpTestData(cls):
# Create 200 Terms
num_terms = 200
TermFactory.create_batch(num_terms)