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.
292 lines
9.4 KiB
292 lines
9.4 KiB
import datetime
|
|
|
|
from accounts.models import User
|
|
from django.contrib.contenttypes.models import ContentType
|
|
from django.core.urlresolvers import reverse, NoReverseMatch
|
|
from django.test import TestCase
|
|
from expobanner.models import Paid, Banner
|
|
from note.models import Note
|
|
from service.models import Service
|
|
from stats_collector.models import ObjectStats
|
|
from theme.models import Tag, Theme
|
|
|
|
from ..models import Conference, Speaker, Statistic, TimeTable
|
|
from city.models import City
|
|
from country.models import Country
|
|
from events.models import TargetAudience
|
|
|
|
|
|
class ConferenceTest(TestCase):
|
|
def setUp(self):
|
|
self.conference = Conference.objects.create(
|
|
name='New Conference',
|
|
data_begin=datetime.datetime.now(),
|
|
data_end=datetime.timedelta(24)+datetime.datetime.now(),
|
|
country=Country.objects.all()[0],
|
|
city=City.objects.all()[0],
|
|
|
|
url='new-conference',
|
|
services=b'0001000'
|
|
)
|
|
|
|
def test_a_conference_create(self):
|
|
conference_count = Conference.objects.all().count()
|
|
Conference.objects.create(
|
|
name='New Conference',
|
|
data_begin=datetime.datetime.now(),
|
|
data_end=datetime.timedelta(24)+datetime.datetime.now(),
|
|
country=Country.objects.all()[0],
|
|
city=City.objects.all()[0]
|
|
)
|
|
new_conference_count = Conference.objects.all().count()
|
|
|
|
self.assertEqual(conference_count + 1, new_conference_count)
|
|
|
|
def test_save_conference_info(self):
|
|
name = 'New Conference'
|
|
datetime_now = datetime.datetime.now()
|
|
data_begin = datetime_now
|
|
data_end = datetime.timedelta(24) + datetime_now
|
|
country = Country.objects.all()[0]
|
|
city = City.objects.all()[0]
|
|
|
|
new_conference = Conference.objects.create(
|
|
name=name,
|
|
data_begin=data_begin,
|
|
data_end=data_end,
|
|
country=country,
|
|
city=city
|
|
|
|
)
|
|
|
|
self.assertEqual(name, new_conference.name)
|
|
self.assertEqual(data_begin, new_conference.data_begin)
|
|
self.assertEqual(data_end, new_conference.data_end)
|
|
self.assertEqual(country, new_conference.country)
|
|
self.assertEqual(city, new_conference.city)
|
|
|
|
def test_method_unicode(self):
|
|
self.assertEqual(
|
|
str(self.conference),
|
|
self.conference.lazy_translation_getter(
|
|
'name', unicode(self.conference.pk))
|
|
)
|
|
|
|
def test_method_get_services(self):
|
|
services = [item for item, bool in self.conference.services if bool]
|
|
qs = Service.objects.language()
|
|
qs = qs.filter(url__in=services)
|
|
|
|
self.assertEqual(
|
|
sorted(self.conference.get_services(), key=lambda x: x.pk),
|
|
sorted(list(qs), key=lambda x: x.pk)
|
|
)
|
|
|
|
def test_method_get_news_url(self):
|
|
self.assertEqual(
|
|
self.conference.get_news_url(),
|
|
reverse('news_conference', kwargs={'slug': self.conference.url})
|
|
)
|
|
|
|
def test_method_get_audience(self):
|
|
self.assertFalse(self.conference.get_audience())
|
|
|
|
self.conference.audience.add(
|
|
TargetAudience.objects.create(title='All'))
|
|
audience = TargetAudience.objects.filter(title='All')[0]
|
|
|
|
self.assertIn(audience, self.conference.get_audience())
|
|
|
|
def test_method_get_calendar_url(self):
|
|
self.assertEqual(
|
|
self.conference.get_calendar_url(),
|
|
reverse('conference_add_calendar', args=[self.conference.id])
|
|
)
|
|
|
|
def test_method_get_visit_url(self):
|
|
self.assertEqual(
|
|
self.conference.get_visit_url(),
|
|
reverse(
|
|
'events:event_visit',
|
|
args=['conference', self.conference.id]
|
|
)
|
|
)
|
|
|
|
def test_method_get_note_url(self):
|
|
self.assertEqual(
|
|
self.conference.get_note_url(),
|
|
reverse('conference_add_note', args=[self.conference.url])
|
|
)
|
|
|
|
def test_method_get_note_by_user(self):
|
|
user = User.objects.all()[0]
|
|
|
|
self.assertEqual(self.conference.get_note_by_user(user.id), '')
|
|
|
|
text = 'Great'
|
|
ct = ContentType.objects.get_for_model(self.conference)
|
|
object_id = self.conference.id
|
|
Note.objects.create(
|
|
content_type=ct, object_id=object_id,
|
|
user=user, text=text
|
|
)
|
|
|
|
self.assertEqual(self.conference.get_note_by_user(user.id), text)
|
|
|
|
def test_method_tags(self):
|
|
self.assertFalse(self.conference.tags())
|
|
|
|
theme = Theme.objects.create(
|
|
name='Theme name', main_title='Theme title'
|
|
)
|
|
tag = Tag.objects.create(
|
|
name='Tag name', main_title='Tag title', theme=theme
|
|
)
|
|
self.conference.tag.add(tag)
|
|
|
|
self.assertIn(tag, self.conference.tags())
|
|
|
|
def test_method_get_index_text(self):
|
|
self.assertIn(
|
|
self.conference.name,
|
|
self.conference.get_index_text()
|
|
)
|
|
|
|
title = 'Conf Title'
|
|
self.conference.main_title = title
|
|
self.conference.save()
|
|
|
|
self.assertIn(title, self.conference.get_index_text())
|
|
|
|
theme_name = 'Theme name'
|
|
theme = Theme.objects.create(
|
|
name=theme_name, main_title='Theme title'
|
|
)
|
|
tag_name = 'Tag name'
|
|
tag = Tag.objects.create(
|
|
name=tag_name, main_title='Tag title', theme=theme
|
|
)
|
|
self.conference.tag.add(tag)
|
|
|
|
self.assertIn(tag_name, self.conference.get_index_text())
|
|
|
|
self.conference.theme.add(theme)
|
|
|
|
self.assertIn(theme_name, self.conference.get_index_text())
|
|
|
|
def test_method_upload_photo_url(self):
|
|
self.assertEqual(
|
|
reverse('conference_upload_photo', args=[self.conference.id]),
|
|
self.conference.upload_photo_url()
|
|
)
|
|
|
|
def test_method_clicks(self):
|
|
with self.assertRaises(AttributeError):
|
|
self.conference.clicks()
|
|
|
|
ticket_url = 'ticket_url/'
|
|
ticket = Banner.objects.create_for_paid(
|
|
self.conference, ticket_url, 'tickets')
|
|
official_url = 'official_url/'
|
|
official = Banner.objects.create_for_paid(
|
|
self.conference, official_url, 'official')
|
|
paid = Paid.objects.create(
|
|
tickets=ticket, official=official, catalog=ticket)
|
|
|
|
self.conference.paid_new = paid
|
|
self.conference.save()
|
|
|
|
self.assertEqual(self.conference.clicks(), 0)
|
|
|
|
self.client.get(ticket.get_click_link())
|
|
|
|
self.assertEqual(self.conference.clicks(), 1)
|
|
|
|
self.client.get(official.get_click_link())
|
|
|
|
self.assertEqual(self.conference.clicks(), 2)
|
|
|
|
def test_method_get_paid_change_url(self):
|
|
try:
|
|
self.conference.get_paid_change_url()
|
|
except NoReverseMatch:
|
|
pass
|
|
|
|
ticket = Banner.objects.create_for_paid(
|
|
self.conference, 'ticket_url', 'tickets')
|
|
official = Banner.objects.create_for_paid(
|
|
self.conference, 'official_url', 'official')
|
|
paid = Paid.objects.create(
|
|
tickets=ticket, official=official, catalog=official)
|
|
|
|
self.conference.paid_new = paid
|
|
self.conference.save()
|
|
|
|
self.assertEqual(
|
|
self.conference.get_paid_change_url(),
|
|
reverse('confbanner-update_paid',
|
|
args=[self.conference.paid_new.id])
|
|
)
|
|
|
|
def test_method_get_objectstat_views(self):
|
|
self.assertEqual(
|
|
self.conference.get_objectstat_views(),
|
|
sum(ObjectStats.objects.filter(
|
|
conference=self.conference).values_list('value', flat=True))
|
|
)
|
|
|
|
|
|
class SpeakerTest(TestCase):
|
|
def test_create_speaker(self):
|
|
speacers = Speaker.objects.all().count()
|
|
Speaker.objects.create(fullname='Hgangu Piter')
|
|
speacers_plus_one = Speaker.objects.all().count()
|
|
|
|
self.assertEqual(speacers + 1, speacers_plus_one)
|
|
|
|
def test_method_unicode(self):
|
|
fullname = 'Hgangu Piter'
|
|
speaker = Speaker.objects.create(fullname=fullname)
|
|
self.assertEqual(str(speaker), fullname)
|
|
|
|
|
|
class StatisticTest(TestCase):
|
|
def test_create_statistic(self):
|
|
stats = Statistic.objects.all().count()
|
|
conf = Conference.objects.create(
|
|
name='New Conference',
|
|
data_begin=datetime.datetime.now(),
|
|
data_end=datetime.timedelta(24)+datetime.datetime.now(),
|
|
country=Country.objects.all()[0],
|
|
city=City.objects.all()[0]
|
|
)
|
|
Statistic.objects.create(
|
|
conference=conf,
|
|
year=datetime.datetime.now().year,
|
|
countries='Monaco'
|
|
)
|
|
stats_plus_one = Statistic.objects.all().count()
|
|
|
|
self.assertEqual(stats + 1, stats_plus_one)
|
|
|
|
|
|
class TimeTableTest(TestCase):
|
|
def test_create_timetable(self):
|
|
tables = TimeTable.objects.all().count()
|
|
conf = Conference.objects.create(
|
|
name='New Conference',
|
|
data_begin=datetime.datetime.now(),
|
|
data_end=datetime.timedelta(24) + datetime.datetime.now(),
|
|
country=Country.objects.all()[0],
|
|
city=City.objects.all()[0]
|
|
)
|
|
TimeTable.objects.create(
|
|
conference=conf,
|
|
begin=datetime.datetime.now(),
|
|
end=datetime.timedelta(24) + datetime.datetime.now(),
|
|
name='All times'
|
|
)
|
|
tables_plus_one = TimeTable.objects.all().count()
|
|
self.assertEqual(
|
|
tables + 1, tables_plus_one
|
|
)
|
|
|