# -*- 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'
        )

###############################################################################