You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1399 lines
42 KiB
1399 lines
42 KiB
# -*- coding: utf-8 -*-
|
|
|
|
from django.core.urlresolvers import reverse, NoReverseMatch
|
|
from django.test import TestCase
|
|
from django.utils.translation import ugettext as _
|
|
from django.conf import settings
|
|
|
|
from city.models import City
|
|
from conference.models import Conference
|
|
from country.models import Country
|
|
|
|
from functions.views_help import get_side_items
|
|
|
|
|
|
###############################################################################
|
|
# ConferenceBy
|
|
###############################################################################
|
|
from theme.models import Theme
|
|
|
|
|
|
class ConferenceByTest(object):
|
|
"""Функционал 'абстрактного' класса ConferenceBy"""
|
|
def setUp(self):
|
|
self.response = self.client.get(self.url)
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'client/conference/conference_by.html'
|
|
)
|
|
|
|
def test_page_is_available(self):
|
|
self.assertEqual(self.response.status_code, 200)
|
|
|
|
def test_titles(self):
|
|
self.assertContains(self.response, self.title1)
|
|
self.assertContains(self.response, self.title2)
|
|
|
|
def test_link(self):
|
|
link = '/conference/%s' % (self.catalog, )
|
|
self.assertContains(self.response, link)
|
|
|
|
def test_queryset(self):
|
|
obj_list = self.response.context[-1].get('object_list')
|
|
for obj in obj_list:
|
|
self.assertContains(
|
|
self.response, obj.name
|
|
)
|
|
self.assertContains(
|
|
self.response, obj.url
|
|
)
|
|
|
|
|
|
class CanFilterAndSidePopular(object):
|
|
"""Функционал can_filter and side_popular in get_context_data"""
|
|
def test_can_filter(self):
|
|
text = 'ВЫБРАТЬ ПО КРИТЕРИЯМ:'
|
|
can_filter = self.response.context[-1].get('can_filter', None)
|
|
if can_filter is False:
|
|
self.assertNotContains(self.response, text)
|
|
elif can_filter is True:
|
|
self.assertContains(self.response, text)
|
|
|
|
def test_side_popular(self):
|
|
side_popular = get_side_items('conf', self.model)
|
|
for popular in side_popular:
|
|
self.assertContains(self.response, popular.get('url'))
|
|
self.assertContains(self.response, popular.get('name'))
|
|
|
|
|
|
###############################################################################
|
|
|
|
|
|
class ConferenceByCountryTest(ConferenceByTest, CanFilterAndSidePopular, TestCase):
|
|
url = reverse('conference_country')
|
|
title1 = _(u'По странам')
|
|
title2 = _(u'Конференции мира по странам')
|
|
catalog = 'country/'
|
|
model = Country
|
|
|
|
|
|
class ConferenceByThemeTest(ConferenceByTest, TestCase):
|
|
url = reverse('conference_theme')
|
|
title1 = _(u'По тематикам')
|
|
title2 = _(u'Конференции мира по тематикам')
|
|
catalog = 'theme/'
|
|
|
|
|
|
class ConferenceByTagTest(ConferenceByTest, TestCase):
|
|
url = reverse('conference_tag')
|
|
title1 = _(u'По тегам')
|
|
title2 = _(u'Конференции мира по тегам')
|
|
catalog = 'tag/'
|
|
|
|
|
|
class ConferenceByCityTest(ConferenceByTest, CanFilterAndSidePopular, TestCase):
|
|
url = reverse('conference_city')
|
|
title1 = _(u'По городам')
|
|
title2 = _(u'Конференции мира по городам')
|
|
catalog = 'city/'
|
|
model = City
|
|
|
|
|
|
###############################################################################
|
|
# ConferenceCatalog
|
|
###############################################################################
|
|
|
|
|
|
class ConferenceCatalogTest(object):
|
|
"""Функционал абстрактного класа ConferenceCatalog_"""
|
|
conf = Conference.objects.all()[0]
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'client/conference/catalog.html'
|
|
)
|
|
|
|
def test_page_is_available(self):
|
|
self.assertEqual(self.response.status_code, 200)
|
|
|
|
def test_context_data(self):
|
|
context = self.response.context[-1]
|
|
|
|
self.assertIn('filter_object', context)
|
|
self.assertIn('year', context)
|
|
self.assertIn('month', context)
|
|
self.assertIn('catalog_url', context)
|
|
|
|
|
|
class CommonConferenceCatalogTest(object):
|
|
def test_slug_wrong(self):
|
|
self.url_kwargs['slug'] = 'liuwyf'
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, 404)
|
|
|
|
def check_page_with_negative_index(self):
|
|
self.url_kwargs['page'] = -1
|
|
try:
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
except NoReverseMatch:
|
|
pass
|
|
|
|
def check_page_is_very_large(self):
|
|
self.url_kwargs['page'] = 1024
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, 302)
|
|
|
|
|
|
class ContextDataCountryCityCatalogTest(object):
|
|
def test_context_data(self):
|
|
context = self.response.context[-1]
|
|
ctx_country_id = context.get('country')[0]
|
|
country = self.model.objects.get(url=self.url_kwargs.get('slug'))
|
|
|
|
self.assertEqual(ctx_country_id, str(country.id))
|
|
|
|
|
|
class ContextDataThemeCatalogTest(object):
|
|
def test_context_data(self):
|
|
context = self.response.context[-1]
|
|
if 'country' in context:
|
|
ctx_country = context.get('country')
|
|
country = Country.objects.get(url=self.url_kwargs.get('country_slug'))
|
|
self.assertEqual(ctx_country, country)
|
|
if 'city' in context:
|
|
ctx_city = context.get('city')
|
|
city = City.objects.get(
|
|
url=self.url_kwargs.get('city_slug'))
|
|
self.assertEqual(ctx_city, city)
|
|
|
|
theme_for_filter = context.get('theme_for_filter')
|
|
ctx_themes = context.get('themes')
|
|
themes = Theme.objects.language().filter(name=theme_for_filter)
|
|
|
|
self.assertEqual(
|
|
sorted(themes.values_list('id', flat=True)),
|
|
sorted([int(i) for i in ctx_themes])
|
|
)
|
|
|
|
def month_convert(number):
|
|
"""
|
|
Переводит числовое представление месяца в строковое
|
|
"""
|
|
mapping = {v['value']: k for k, v in settings.MONTHES.items()}
|
|
return mapping.get(number)
|
|
|
|
|
|
###############################################################################
|
|
# ConferenceCountryCatalog
|
|
|
|
|
|
class ConferenceCountryCatalogSlugYearMonthPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conference_country_catalog_slug_year_month_page'
|
|
model = Country
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
self.url_kwargs = {
|
|
'slug': self.conf.country.url,
|
|
'year': self.conf.data_end.year,
|
|
'month': month_convert(self.month),
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
country__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
data_begin__month=self.month
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
|
|
class ConferenceCountryCatalogSlugYearPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conference_country_catalog_slug_year_page'
|
|
model = Country
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
self.url_kwargs = {
|
|
'slug': self.conf.country.url,
|
|
'year': self.conf.data_end.year,
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
country__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
|
|
class ConferenceCountryCatalogSlugPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conference_country_catalog_slug_page'
|
|
model = Country
|
|
|
|
def setUp(self):
|
|
self.url_kwargs = {
|
|
'slug': self.conf.country.url,
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
country__url=self.url_kwargs.get('slug')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
|
|
class ConferenceCountryCatalogSlugYearMonthTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conference_country_catalog_slug_year_month'
|
|
model = Country
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
self.url_kwargs = {
|
|
'slug': self.conf.country.url,
|
|
'year': self.conf.data_end.year,
|
|
'month': month_convert(self.month)
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
country__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
data_begin__month=self.month
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
|
|
class ConferenceCountryCatalogSlugYearTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conference_country_catalog_slug_year'
|
|
model = Country
|
|
|
|
def setUp(self):
|
|
self.url_kwargs = {
|
|
'slug': self.conf.country.url,
|
|
'year': self.conf.data_end.year,
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
country__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
|
|
class ConferenceCountryCatalogSlugTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conf_country'
|
|
model = Country
|
|
|
|
def setUp(self):
|
|
self.url_kwargs = {
|
|
'slug': self.conf.country.url,
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
country__url=self.url_kwargs.get('slug')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
|
|
###############################################################################
|
|
# ConferenceCityCatalog
|
|
|
|
|
|
class ConferenceCityCatalogSlugYearMonthPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conference_city_catalog_slug_year_month_page'
|
|
model = City
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
self.url_kwargs = {
|
|
'slug': self.conf.city.url,
|
|
'year': self.conf.data_end.year,
|
|
'month': month_convert(self.month),
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
city__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
data_begin__month=self.month
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
|
|
class ConferenceCityCatalogSlugYearPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conference_city_catalog_slug_year_page'
|
|
model = City
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
self.url_kwargs = {
|
|
'slug': self.conf.city.url,
|
|
'year': self.conf.data_end.year,
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
city__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
|
|
class ConferenceCityCatalogSlugPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conference_city_catalog_slug_page'
|
|
model = City
|
|
|
|
def setUp(self):
|
|
self.url_kwargs = {
|
|
'slug': self.conf.city.url,
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
city__url=self.url_kwargs.get('slug')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
|
|
class ConferenceCityCatalogSlugYearMonthTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conference_city_catalog_slug_year_month'
|
|
model = City
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
self.url_kwargs = {
|
|
'slug': self.conf.city.url,
|
|
'year': self.conf.data_end.year,
|
|
'month': month_convert(self.month)
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
city__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
data_begin__month=self.month
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
|
|
class ConferenceCityCatalogSlugYearTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conference_city_catalog_slug_year'
|
|
model = City
|
|
|
|
def setUp(self):
|
|
self.url_kwargs = {
|
|
'slug': self.conf.city.url,
|
|
'year': self.conf.data_end.year,
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
city__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
|
|
class ConferenceCityCatalogSlugTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataCountryCityCatalogTest, TestCase):
|
|
url_name = 'conf_city'
|
|
model = City
|
|
|
|
def setUp(self):
|
|
self.url_kwargs = {
|
|
'slug': self.conf.city.url,
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
city__url=self.url_kwargs.get('slug')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
|
|
###############################################################################
|
|
# ConferenceThemeCatalog
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCountryslugYearMonthPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_countryslug_year_month_page'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'country_slug': self.conf.country.url,
|
|
'year': self.conf.data_end.year,
|
|
'month': month_convert(self.month),
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
country__url=self.url_kwargs.get('country_slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
data_begin__month=self.month
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
# TODO вынести в родительский клас
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCountryslugYearPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_countryslug_year_page'
|
|
|
|
def setUp(self):
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'country_slug': self.conf.country.url,
|
|
'year': self.conf.data_end.year,
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
country__url=self.url_kwargs.get('country_slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCountryslugYearMonthTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_countryslug_year_month'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'country_slug': self.conf.country.url,
|
|
'year': self.conf.data_end.year,
|
|
'month': month_convert(self.month)
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
country__url=self.url_kwargs.get('country_slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
data_begin__month=self.month
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCountryslugPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_countryslug_page'
|
|
|
|
def setUp(self):
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'country_slug': self.conf.country.url,
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
country__url=self.url_kwargs.get('country_slug'),
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCountryslugYearTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_countryslug_year'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'country_slug': self.conf.country.url,
|
|
'year': self.conf.data_end.year
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
country__url=self.url_kwargs.get('country_slug'),
|
|
data_end__year=self.url_kwargs.get('year')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
class ConferenceThemeCatalogSlugCountryslugTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_countryslug'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'country_slug': self.conf.country.url
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
country__url=self.url_kwargs.get('country_slug')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCityslugYearMonthPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_cityslug_year_month_page'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'city_slug': self.conf.city.url,
|
|
'year': self.conf.data_end.year,
|
|
'month': month_convert(self.month),
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
city__url=self.url_kwargs.get('city_slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
data_begin__month=self.month
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCityslugYearPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_cityslug_year_page'
|
|
|
|
def setUp(self):
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'city_slug': self.conf.city.url,
|
|
'year': self.conf.data_end.year,
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
city__url=self.url_kwargs.get('city_slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCityslugYearMonthTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_cityslug_year_month'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'city_slug': self.conf.city.url,
|
|
'year': self.conf.data_end.year,
|
|
'month': month_convert(self.month)
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
city__url=self.url_kwargs.get('city_slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
data_begin__month=self.month
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCityslugPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_cityslug_page'
|
|
|
|
def setUp(self):
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'city_slug': self.conf.city.url,
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
city__url=self.url_kwargs.get('city_slug'),
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCityslugYearTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_cityslug_year'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'city_slug': self.conf.city.url,
|
|
'year': self.conf.data_end.year
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
city__url=self.url_kwargs.get('city_slug'),
|
|
data_end__year=self.url_kwargs.get('year')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugCityslugTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_cityslug'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'city_slug': self.conf.city.url
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
city__url=self.url_kwargs.get('city_slug')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugYearMonthPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_year_month_page'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'year': self.conf.data_end.year,
|
|
'month': month_convert(self.month),
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
data_begin__month=self.month
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugYearPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_year_page'
|
|
|
|
def setUp(self):
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'year': self.conf.data_end.year,
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugPageTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_page'
|
|
|
|
def setUp(self):
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'page': 1
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_page_with_negative_index(self):
|
|
self.check_page_with_negative_index()
|
|
|
|
def test_page_is_very_large(self):
|
|
self.check_page_is_very_large()
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugYearMonthTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_year_month'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'year': self.conf.data_end.year,
|
|
'month': month_convert(self.month)
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year'),
|
|
data_begin__month=self.month
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugYearTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug_year'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug,
|
|
'year': self.conf.data_end.year
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug'),
|
|
data_end__year=self.url_kwargs.get('year')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
|
|
class ConferenceThemeCatalogSlugTest(
|
|
ConferenceCatalogTest, CommonConferenceCatalogTest,
|
|
ContextDataThemeCatalogTest, TestCase):
|
|
url_name = 'conference_theme_catalog_slug'
|
|
|
|
def setUp(self):
|
|
self.month = self.conf.data_begin.month
|
|
theme_slug = self.conf.theme.all()[0].url
|
|
self.url_kwargs = {
|
|
'slug': theme_slug
|
|
}
|
|
url = reverse(
|
|
self.url_name,
|
|
kwargs=self.url_kwargs
|
|
)
|
|
self.response = self.client.get(url)
|
|
|
|
def test_queryset(self):
|
|
object_list = self.response.context[-1].get('object_list')
|
|
|
|
conferences = Conference.objects.filter(
|
|
theme__url=self.url_kwargs.get('slug')
|
|
)
|
|
|
|
self.assertEqual(
|
|
sorted(list(object_list), key=lambda x: x.pk),
|
|
sorted(list(conferences), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_template(self):
|
|
self.assertTemplateUsed(
|
|
self.response,
|
|
'conference/catalog_theme.html'
|
|
)
|
|
|
|
###############################################################################
|
|
|
|
|
|
|
|
|