def setUp( self ):
# test user with no permissions
self.u1 = User.objects.create_user( "user", "*****@*****.**", "user" )
# test user with moderation_permission
self.u2 = User.objects.create_user( "root", "*****@*****.**", "root" )
self.u2.user_permissions.add( Permission.objects.get( codename="can_add_link" ) )
self.u2.save()
# set up film
self.film = Film()
self.film.title = "Battlefield Earth II"
self.film.type = Object.TYPE_FILM
self.film.permalink = "battlefirld-earth-ii"
self.film.release_year = 2010
self.film.save()
# set up links
self.link1 = ExternalLink( user=self.u2, film=self.film, permalink='LINK', version=1,
type=ExternalLink.TYPE_LINK, status=ExternalLink.PUBLIC_STATUS,
url_kind = ExternalLink.TRAILER, url="http://yt.com" )
self.link2 = ExternalLink( user=self.u2, film=self.film, permalink='LINK', version=1,
type=ExternalLink.TYPE_LINK, status=ExternalLink.PUBLIC_STATUS,
url_kind = ExternalLink.TRAILER, url="http://yt.com/v=1" )
self.link1.save()
self.link2.save()
def setUp( self ):
self.u1 = User.objects.create_user( "user", "*****@*****.**", "user" )
self.u1.is_superuser = True
self.u1.save()
self.u2 = User.objects.create_user( "user2", "*****@*****.**", "user2" )
self.u3 = User.objects.create_user( "user3", "*****@*****.**", "user3" )
self.u4 = User.objects.create_user( "user4", "*****@*****.**", "user4" )
self.f1 = Film()
self.f1.title = "Battlefield Earth II"
self.f1.type = Object.TYPE_FILM
self.f1.permalink = "battlefirld-earth-ii"
self.f1.release_year = 2010
self.f1.production_country_list = "USA"
self.f1.save()
self.f1.save_tags( "sciencie-fiction komedia test1 test2", LANG="pl", saved_by=2)
self.f2 = Film()
self.f2.title = "Battlefield Earth II 2"
self.f2.type = Object.TYPE_FILM
self.f2.permalink = "battlefirld-earth-ii-2"
self.f2.release_year = 2010
self.f2.production_country_list = "USA"
self.f2.save()
self.f2.save_tags( "sciencie komedia test1", LANG="pl", saved_by=2)
rating_helper.rate(self.u1, 1, self.f1.id)
rating_helper.rate(self.u1, 2, self.f2.id)
rating_helper.rate(self.u2, 3, self.f1.id)
rating_helper.rate(self.u3, 3, self.f1.id)
rating_helper.rate(self.u4, 3, self.f2.id)
def setUp(self):
self.u1 = User.objects.create_user("user", "*****@*****.**", "user")
self.u1.is_superuser = True
self.u1.save()
self.u2 = User.objects.create_user("user2", "*****@*****.**", "user2")
self.u3 = User.objects.create_user("user3", "*****@*****.**", "user3")
self.u4 = User.objects.create_user("user4", "*****@*****.**", "user4")
self.f1 = Film()
self.f1.title = "Battlefield Earth II"
self.f1.type = Object.TYPE_FILM
self.f1.permalink = "battlefirld-earth-ii"
self.f1.release_year = 2010
self.f1.production_country_list = "USA"
self.f1.save()
self.f1.save_tags("sciencie-fiction komedia test1 test2",
LANG="pl",
saved_by=2)
self.f2 = Film()
self.f2.title = "Battlefield Earth II 2"
self.f2.type = Object.TYPE_FILM
self.f2.permalink = "battlefirld-earth-ii-2"
self.f2.release_year = 2010
self.f2.production_country_list = "USA"
self.f2.save()
self.f2.save_tags("sciencie komedia test1", LANG="pl", saved_by=2)
rating_helper.rate(self.u1, 1, self.f1.id)
rating_helper.rate(self.u1, 2, self.f2.id)
rating_helper.rate(self.u2, 3, self.f1.id)
rating_helper.rate(self.u3, 3, self.f1.id)
rating_helper.rate(self.u4, 3, self.f2.id)
def refill_tag_basket(cls, user, tag):
TAG_BASKET_SIZE = getattr(settings, 'TAG_BASKET_SIZE')
MIN_TAG_BASKET_SIZE = getattr(settings, 'MIN_TAG_BASKET_SIZE')
try:
lang = user.get_profile().LANG
except AttributeError:
lang = 'en'
basket_key = cache.Key(cache.CACHE_TAG_BASKET, user, tag)
tag_basket = cache.get(basket_key) or dict()
if len(tag_basket) < MIN_TAG_BASKET_SIZE:
# get films with this tag
films_dict = Film.get_film_ids_by_tag(tag, lang)
# get films seen by user
seen_films = Film.get_user_seen_films(user)
# remove films seen by user
films_dict = dict([(k,v) for k,v in films_dict.items() if k not in seen_films])
# how many we want to refill
to_refill = TAG_BASKET_SIZE - len(tag_basket)
# reverse sort by popularity
sorted_films = sorted(films_dict, key=films_dict.get, reverse=True)[:to_refill]
refill_dict = dict([(fid, films_dict[fid]) for fid in sorted_films])
tag_basket.update(refill_dict)
cache.set(basket_key, tag_basket, cache.A_MONTH)
class FilmBasketTestCase(TestCase):
def setUp(self):
self.user = User.objects.create_user("user", "*****@*****.**", "user")
self.film = Film( type=1, permalink='przypadek', imdb_code=111, status=1, version=1, \
release_year=1999, title='Przypadek' )
self.film.save()
def tearDown(self):
User.objects.all().delete()
Film.objects.all().delete()
BasketItem.objects.all().delete()
def testRatingRemoveFromWishlist(self):
BasketItem.objects.create(film=self.film,
wishlist=BasketItem.DYING_FOR,
user=self.user)
self.assertEqual(len(BasketItem.user_basket(self.user)), 1)
rating_helper.rate(self.user, 5, film_id=self.film.id)
bi = BasketItem.objects.get(film=self.film, user=self.user)
self.assertTrue(bi.wishlist is None)
def get_seen_films(user):
if settings.USE_REDIS:
seen_ids = redis_intf.get_seen_films(user)
else:
seen_ids = Film._recently_seen_film_ids(user)
seen_ids.difference_update(Film._long_ago_seen_film_ids(user))
return seen_ids
def initialize(self):
self.clean_data()
# set up users
self.u1 = User.objects.create_user('michuk',
'*****@*****.**',
'secret')
self.u1.save()
# set up film
self.film = Film()
self.film.id = 233
self.film.title = "Battlefield Earth II"
self.film.type = Object.TYPE_FILM
self.film.permalink = "battlefirld-earth-ii"
self.film.release_year = 2010
self.film.save(saved_by=2)
self.film.save_tags("tag1", LANG="pl", saved_by=2)
# set up film
self.film1 = Film()
self.film1.id = 236
self.film1.title = "Battlefield Earth III"
self.film1.type = Object.TYPE_FILM
self.film1.permalink = "battlefirld-earth-iii"
self.film1.release_year = 2011
self.film1.save(saved_by=2)
self.film1.save_tags("tag2", LANG="pl", saved_by=2)
# set up activities
sr = UserActivity(user=self.u1,
film=self.film,
object=self.film,
content="Lorem",
activity_type=UserActivity.TYPE_SHORT_REVIEW,
featured=True)
sr.save()
sr1 = UserActivity()
sr1.user = self.u1
sr1.film = self.film1
sr1.object = self.film1
sr1.content = "ipsum"
sr1.activity_type = UserActivity.TYPE_SHORT_REVIEW
sr1.featured = True
sr1.save()
rating1 = UserActivity()
rating1.activity_type = UserActivity.TYPE_RATING
rating1.user = self.u1
rating1.object = self.film
rating1.featured = True
rating1.save()
rating2 = UserActivity()
rating2.activity_type = UserActivity.TYPE_RATING
rating2.user = self.u1
rating2.object = self.film
rating2.featured = True
rating2.save()
class FilmBasketTestCase( TestCase ):
def setUp( self ):
self.user = User.objects.create_user( "user", "*****@*****.**", "user" )
self.film = Film( type=1, permalink='przypadek', imdb_code=111, status=1, version=1, \
release_year=1999, title='Przypadek' )
self.film.save()
def tearDown( self ):
User.objects.all().delete()
Film.objects.all().delete()
Rating.objects.all().delete()
BasketItem.objects.all().delete()
def testRatingRemoveFromWishlist( self ):
BasketItem.objects.create( film=self.film, wishlist=BasketItem.DYING_FOR, user=self.user )
self.assertEqual( len( BasketItem.user_basket( self.user ) ), 1 )
Rating.objects.create( type=Rating.TYPE_FILM, film=self.film, rating=5,
parent=self.film, user=self.user)
bi = BasketItem.objects.get( film=self.film, user=self.user )
self.assertTrue( bi.wishlist is None )
def film_from_film_on_channel(f):
film = Film(
title=f.title,
permalink="unmatched-film-%d" % f.pk,
image=None,
production_country_list='',
)
film._directors = f.directors
return film
def get_films(self):
key = cache.Key("festival_films", self)
films = cache.get(key)
if films is None:
films = Film.objects.tagged(self.tag.lower())
films = list(films[:1000])
Film.update_ranking(films)
cache.set(key, films)
return films
def film_from_film_on_channel(f):
film = Film(
title=f.title,
permalink="unmatched-film-%d" % f.pk,
image=None,
production_country_list='',
)
film._directors = f.directors
return film
def get_films(self):
key = cache.Key("festival_films", self)
films = cache.get(key)
if films is None:
films = Film.objects.tagged(self.tag.lower())
films = list(films[:1000])
Film.update_ranking(films)
cache.set(key, films)
return films
def setUp(self):
# set up films
self.film1 = Film()
self.film1.title = "Battlefield Earth II"
self.film1.type = Object.TYPE_FILM
self.film1.permalink = "battlefirld-earth-ii"
self.film1.release_year = 2010
self.film1.production_country_list = "USA"
self.film1.save()
self.film1.save_tags("sciencie-fiction komedia test1 test2",
LANG="pl",
saved_by=2)
self.film2 = Film()
self.film2.title = "Battlefield Earth III"
self.film2.type = Object.TYPE_FILM
self.film2.permalink = "battlefirld-earth-iii"
self.film2.release_year = 2011
self.film2.production_country_list = "USA"
self.film2.save()
self.film2.save_tags("sciencie-fiction komedia test1",
LANG="pl",
saved_by=2)
self.film3 = Film()
self.film3.title = "Battlefield Earth IV"
self.film3.type = Object.TYPE_FILM
self.film3.permalink = "battlefirld-earth-iv"
self.film3.release_year = 2012
self.film3.production_country_list = "Italy"
self.film3.save()
self.film3.save_tags("sciencie-fiction komedia test3 test5",
LANG="pl",
saved_by=2)
self.film4 = Film()
self.film4.title = "Battlefield Earth V"
self.film4.type = Object.TYPE_FILM
self.film4.permalink = "battlefirld-earth-v"
self.film4.release_year = 2013
self.film4.production_country_list = "UK"
self.film4.save()
self.film4.save_tags("sciencie-fiction komedia test5",
LANG="en",
saved_by=2)
self.film4.save_tags("sciencie-fiction komedia", LANG="en", saved_by=2)
self.film5 = Film()
self.film5.title = "Battlefield Earth VI"
self.film5.type = Object.TYPE_FILM
self.film5.permalink = "battlefirld-earth-vi"
self.film5.release_year = 2013
self.film5.production_country_list = "UK"
self.film5.save()
self.film5.save_tags("sciencie-fiction comedy", LANG="en", saved_by=2)
def testQueuedItem(self):
self.assertEqual(QueuedItem.objects.count(), 1)
self.assertTrue(
isinstance(QueuedItem.objects.all()[0].content_object, User))
f = Film( type=1, permalink='przypadek', imdb_code=111, status=1, version=1, \
release_year=1999, title='Przypadek' )
f.save()
self.assertEqual(QueuedItem.objects.count(), 3)
self.assertTrue(
isinstance(QueuedItem.objects.all()[1].content_object, Film))
modified_at = QueuedItem.objects.all()[1].modified_at
f.title = 'Przypadek - test'
f.save()
self.assertEqual(QueuedItem.objects.count(), 3)
self.assertTrue(QueuedItem.objects.all()[1].modified_at > modified_at)
f.delete()
self.assertEqual(QueuedItem.objects.all()[1].action_type,
QueuedItem.ACTION_REMOVED)
self.assertEqual(QueuedItem.objects.count(), 3)
def initialize(self):
self.clean_data()
# set up users
self.u1= User.objects.create_user('michuk', '*****@*****.**', 'secret')
self.u1.save()
# set up film
self.film = Film()
self.film.id = 233
self.film.title = "Battlefield Earth II"
self.film.type = Object.TYPE_FILM
self.film.permalink = "battlefirld-earth-ii"
self.film.release_year = 2010
self.film.save(saved_by=2)
self.film.save_tags("tag1", LANG="pl", saved_by=2)
# set up film
self.film1 = Film()
self.film1.id = 236
self.film1.title = "Battlefield Earth III"
self.film1.type = Object.TYPE_FILM
self.film1.permalink = "battlefirld-earth-iii"
self.film1.release_year = 2011
self.film1.save(saved_by=2)
self.film1.save_tags("tag2", LANG="pl", saved_by=2)
# set up activities
sr = UserActivity(user=self.u1, film=self.film, object=self.film,
content="Lorem", activity_type=UserActivity.TYPE_SHORT_REVIEW,
featured=True)
sr.save()
sr1 = UserActivity()
sr1.user = self.u1
sr1.film = self.film1
sr1.object = self.film1
sr1.content = "ipsum"
sr1.activity_type = UserActivity.TYPE_SHORT_REVIEW
sr1.featured = True
sr1.save()
rating1 = UserActivity()
rating1.activity_type = UserActivity.TYPE_RATING
rating1.user = self.u1
rating1.object = self.film
rating1.featured = True
rating1.save()
rating2 = UserActivity()
rating2.activity_type = UserActivity.TYPE_RATING
rating2.user = self.u1
rating2.object = self.film
rating2.featured = True
rating2.save()
def test_filmindb(self):
"""
Test failed fetch movie in db
"""
self.initialize()
self.client.login(username=self.user.username, password='******')
film_to_import = FilmToImport(user = self.user,
title = 'Elektroniczny Morderca',
imdb_url = 'http://www.imdb.com/title/tt0088247/',
imdb_id='0088247',
status=FilmToImport.ACCEPTED)
film_to_import.save()
film = Film()
film.title = "The Terminator"
film.type = Object.TYPE_FILM
film.imdb_code = "0088247"
film.permalink = "the-terminator"
film.release_year = 1984
film.save()
run(False, False, False, False, False, True, "http")
film_to_import = FilmToImport.objects.get(title = 'Elektroniczny Morderca')
self.assertEqual(film_to_import.attempts, 1)
self.assertEqual(film_to_import.status, FilmToImport.ALREADY_IN_DB)
class RequestTestCase(TestCase):
fixtures = ['test_users.json']
def setUp(self):
self.user = User.objects.get(username='******')
self.user.set_password('bob')
self.user.save()
self.film = Film(type=1,
permalink='przypadek',
imdb_code=111,
status=1,
version=1,
release_year=1999,
title='Przypadek',
popularity=1,
popularity_month=1)
self.film.save()
self.person = Person(type=2,
permalink='jerzy-stuhr',
imdb_code=112,
status=1,
version=1,
name='Jerzy',
surname='Stuhr')
self.person.save()
def test_index(self):
response = self.client.get('/')
self.failUnlessEqual(response.status_code, 200)
def test_film(self):
response = self.client.get('/film/przypadek/')
self.failUnlessEqual(response.status_code, 200)
def test_film_authorized(self):
self.client.login(username='******', password='******')
response = self.client.get('/film/przypadek/')
self.assertTrue(response.context['request'].user.is_authenticated())
self.failUnlessEqual(response.status_code, 200)
def test_person(self):
response = self.client.get(self.person.get_absolute_url())
self.assertEquals(response.status_code, 200)
def test_person_authorized(self):
self.client.login(username='******', password='******')
response = self.client.get(self.person.get_absolute_url())
self.assertEquals(response.status_code, 200)
def tearDown(self):
Person.objects.all().delete()
Film.objects.all().delete()
def testQueueCommand( self ):
f = Film( type=1, permalink='przypadek', imdb_code=111, status=1, version=1, \
release_year=1999, title='Przypadek' )
f.save()
f.delete()
self.assertEqual( QueuedItem.objects.count(), 3 )
call_command( 'update_index_queue' )
self.assertEqual( QueuedItem.objects.count(), 1 )
class SimilarFilmsTestCase(TestCase):
def setUp(self):
self.u1 = User.objects.create_user("user1", "*****@*****.**", "user")
self.u2 = User.objects.create_user("user2", "*****@*****.**", "user")
self.u3 = User.objects.create_user("user3", "*****@*****.**", "user")
self.f1 = Film()
self.f1.title = "Battlefield Earth"
self.f1.type = Film.TYPE_FILM
self.f1.permalink = "battlefirld-earth"
self.f1.release_year = 208
self.f1.production_country_list = "USA"
self.f1.save()
self.f2 = Film()
self.f2.title = "Battlefield Earth II"
self.f2.type = Film.TYPE_FILM
self.f2.permalink = "battlefirld-earth-ii"
self.f2.release_year = 2010
self.f2.production_country_list = "USA"
self.f2.save()
def tearsDown(self):
Film.objects.all().delete()
SimilarFilm.objects.all().delete()
def test_votes(self):
SimilarFilm.add_vote(user=self.u1, film_a=self.f1, film_b=self.f2) #1
SimilarFilm.add_vote(user=self.u2, film_a=self.f1, film_b=self.f2) #2
SimilarFilm.add_vote(user=self.u3, film_a=self.f1, film_b=self.f2) #3
SimilarFilm.add_vote(user=self.u3, film_a=self.f2, film_b=self.f1) #4
self.assertEqual(SimilarFilm.objects.filter(film_a=self.f1).count(), 1)
similar = SimilarFilm.objects.get(film_a=self.f1)
self.assertEqual(similar.number_of_votes, 3)
SimilarFilm.remove_vote(user=self.u1, film_a=self.f1,
film_b=self.f2) #2
similar = SimilarFilm.objects.get(film_a=self.f1)
self.assertEqual(similar.number_of_votes, 2)
SimilarFilm.remove_vote(user=self.u2, film_a=self.f1,
film_b=self.f2) #1
similar = SimilarFilm.objects.get(film_a=self.f1)
self.assertEqual(similar.number_of_votes, 1)
SimilarFilm.remove_vote(user=self.u3, film_a=self.f1,
film_b=self.f2) #1
self.assertEqual(SimilarFilm.objects.filter(film_a=self.f1).count(), 0)
class SimilarFilmsTestCase( TestCase ):
def setUp( self ):
self.u1 = User.objects.create_user( "user1", "*****@*****.**", "user" )
self.u2 = User.objects.create_user( "user2", "*****@*****.**", "user" )
self.u3 = User.objects.create_user( "user3", "*****@*****.**", "user" )
self.f1 = Film()
self.f1.title = "Battlefield Earth"
self.f1.type = Film.TYPE_FILM
self.f1.permalink = "battlefirld-earth"
self.f1.release_year = 208
self.f1.production_country_list = "USA"
self.f1.save()
self.f2 = Film()
self.f2.title = "Battlefield Earth II"
self.f2.type = Film.TYPE_FILM
self.f2.permalink = "battlefirld-earth-ii"
self.f2.release_year = 2010
self.f2.production_country_list = "USA"
self.f2.save()
def tearsDown( self ):
Film.objects.all().delete()
SimilarFilm.objects.all().delete()
def test_votes( self ):
SimilarFilm.add_vote( user=self.u1, film_a=self.f1, film_b=self.f2 )#1
SimilarFilm.add_vote( user=self.u2, film_a=self.f1, film_b=self.f2 )#2
SimilarFilm.add_vote( user=self.u3, film_a=self.f1, film_b=self.f2 )#3
SimilarFilm.add_vote( user=self.u3, film_a=self.f2, film_b=self.f1 )#4
self.assertEqual( SimilarFilm.objects.filter( film_a=self.f1 ).count(), 1 )
similar = SimilarFilm.objects.get( film_a=self.f1 )
self.assertEqual( similar.number_of_votes, 3 )
SimilarFilm.remove_vote( user=self.u1, film_a=self.f1, film_b=self.f2 )#2
similar = SimilarFilm.objects.get( film_a=self.f1 )
self.assertEqual( similar.number_of_votes, 2 )
SimilarFilm.remove_vote( user=self.u2, film_a=self.f1, film_b=self.f2 )#1
similar = SimilarFilm.objects.get( film_a=self.f1 )
self.assertEqual( similar.number_of_votes, 1 )
SimilarFilm.remove_vote( user=self.u3, film_a=self.f1, film_b=self.f2 )#1
self.assertEqual( SimilarFilm.objects.filter( film_a=self.f1 ).count(), 0 )
def setUp(self):
# set up films
self.film1 = Film()
self.film1.title = "Film 1"
self.film1.type = Object.TYPE_FILM
self.film1.permalink = "film-1"
self.film1.release_year = 2010
self.film1.production_country_list = "USA"
self.film1.save()
self.film1.save_tags("dramat komedia ", LANG="pl", saved_by=2)
self.film1.save_tags("drama comedy wizards ", LANG="en", saved_by=2)
def test_watching_notification(self):
"""
Testing notifications for different types of activities (posts, short reviews and threads)
"""
self.initialize()
activity = UserActivity.objects.get_for_object(self.post1)
# create two comments for blog post by two different users
t = ThreadedComment(user=self.u2,
comment="This is a comment",
content_object=activity,
type=Object.TYPE_COMMENT)
t.save()
t = ThreadedComment(user=self.u3,
comment="This is also a comment",
content_object=activity,
type=Object.TYPE_COMMENT)
t.save()
# create film and a short review and a comment to it
f1 = Film(type=1,
permalink='przypadek',
imdb_code=111,
status=1,
version=1,
release_year=1999,
title='Przypadek',
popularity=1,
popularity_month=1)
f1.save()
sr = ShortReview(user=self.u1,
review_text="This is a short review",
object=f1,
type=Object.TYPE_SHORT_REVIEW)
sr.save()
activity2 = UserActivity.objects.get_for_object(sr)
t = ThreadedComment(user=self.u2,
comment="This is a comment to a short review",
content_object=activity2,
type=Object.TYPE_COMMENT)
t.save()
# assert all is fine
watching_objects = Watching.objects.all()
self.assertEquals(
len(watching_objects), 5
) # number of unique comments in threads should be equal to watching objects
reply_notices = notification.Notice.objects.filter(
notice_type__label='reply')
# TODO: uncommend and fix in http://jira.filmaster.org/browse/FLM-1116
self.assertEquals(len(reply_notices), 4) # number of notices
def create_films(self):
self.film1 = Film()
self.film1.title = "The Terminator"
self.film1.type = Object.TYPE_FILM
self.film1.permalink = "the-terminator"
self.film1.release_year = 1984
self.film1.save()
self.film2 = Film()
self.film2.title = "Rambo"
self.film2.type = Object.TYPE_FILM
self.film2.permalink = "rambo"
self.film2.release_year = 1982
self.film2.save()
def initialize(self):
self.clean_data()
# set up users
self.u1= User.objects.create_user('michuk', '*****@*****.**', 'secret')
self.u1.save()
# set up film
self.film = Film()
self.film.title = "Battlefield Earth II"
self.film.type = Object.TYPE_FILM
self.film.permalink = "battlefirld-earth-ii"
self.film.release_year = 2010
self.film.save()
def test_filmindb(self):
"""
Test failed fetch movie in db
"""
self.initialize()
self.client.login(username=self.user.username, password='******')
film_to_import = FilmToImport(user = self.user,
title = 'Elektroniczny Morderca',
imdb_url = 'http://www.imdb.com/title/tt0088247/',
imdb_id='0088247',
status=FilmToImport.ACCEPTED)
film_to_import.save()
film = Film()
film.title = "The Terminator"
film.type = Object.TYPE_FILM
film.imdb_code = "0088247"
film.permalink = "the-terminator"
film.release_year = 1984
film.save()
run(False, False, False, False, False, True, "http")
film_to_import = FilmToImport.objects.get(title = 'Elektroniczny Morderca')
self.assertEqual(film_to_import.attempts, 1)
self.assertEqual(film_to_import.status, FilmToImport.ALREADY_IN_DB)
def create_films(self):
self.film1 = Film()
self.film1.title = "The Terminator"
self.film1.type = Object.TYPE_FILM
self.film1.permalink = "the-terminator"
self.film1.release_year = 1984
self.film1.save()
self.film2 = Film()
self.film2.title = "Rambo"
self.film2.type = Object.TYPE_FILM
self.film2.permalink = "rambo"
self.film2.release_year = 1982
self.film2.save()
def initialize(self):
self.clean_data()
# set up film
self.film = Film()
self.film.title = "Battlefield Earth II"
self.film.type = Film.TYPE_FILM
self.film.permalink = "battlefirld-earth-ii"
self.film.release_year = 2010
self.film.save()
filename = "First_blood_poster.jpg"
myfile = MEDIA_ROOT + "test/First_blood_poster.jpg"
f = open(myfile, 'rb')
myfile = File(f)
self.film.image.save(filename, myfile)
def initialize(self):
self.clean_data()
film = Film()
film.title = "The Terminator"
film.type = Object.TYPE_FILM
film.imdb_code = "0088247"
film.permalink = "the-terminator"
film.release_year = 1984
film.save()
self.film = film
def setUp( self ):
# set up films
self.film1 = Film()
self.film1.title = "Battlefield Earth II"
self.film1.type = Object.TYPE_FILM
self.film1.permalink = "battlefirld-earth-ii"
self.film1.release_year = 2010
self.film1.production_country_list = "USA"
self.film1.save()
self.film1.save_tags( "sciencie-fiction komedia test1 test2", LANG="pl", saved_by=2)
self.film2 = Film()
self.film2.title = "Battlefield Earth III"
self.film2.type = Object.TYPE_FILM
self.film2.permalink = "battlefirld-earth-iii"
self.film2.release_year = 2011
self.film2.production_country_list = "USA"
self.film2.save()
self.film2.save_tags("sciencie-fiction komedia test1", LANG="pl", saved_by=2)
self.film3 = Film()
self.film3.title = "Battlefield Earth IV"
self.film3.type = Object.TYPE_FILM
self.film3.permalink = "battlefirld-earth-iv"
self.film3.release_year = 2012
self.film3.production_country_list = "Italy"
self.film3.save()
self.film3.save_tags("sciencie-fiction komedia test3 test5", LANG="pl", saved_by=2)
self.film4 = Film()
self.film4.title = "Battlefield Earth V"
self.film4.type = Object.TYPE_FILM
self.film4.permalink = "battlefirld-earth-v"
self.film4.release_year = 2013
self.film4.production_country_list = "UK"
self.film4.save()
self.film4.save_tags("sciencie-fiction komedia test5", LANG="en", saved_by=2)
self.film4.save_tags("sciencie-fiction komedia", LANG="en", saved_by=2)
self.film5 = Film()
self.film5.title = "Battlefield Earth VI"
self.film5.type = Object.TYPE_FILM
self.film5.permalink = "battlefirld-earth-vi"
self.film5.release_year = 2013
self.film5.production_country_list = "UK"
self.film5.save()
self.film5.save_tags("sciencie-fiction comedy", LANG="en", saved_by=2)
def random_film_to_rate(request):
"""
Widget for main page (for not logged in users)
displaying a film to rate, selected from
the list of 10 most popular films.
"""
user = request.user
if user.is_authenticated():
film = Film.get_next_film_to_rate(user)
else:
key = cache.Key("popular_films_list")
popular_films = cache.get(key)
if popular_films is None:
fhelper = FilmHelper()
lang = getattr(settings, 'LANGUAGE_CODE', 'en')
if lang == 'en':
popular_films = fhelper.get_popular_films(
exclude_nonEnglish=True)
else:
popular_films = fhelper.get_popular_films()
cache.set(key, popular_films)
film = popular_films and random.choice(popular_films) or None
return {
'film': film,
}
def user_recommendations(user, films, with_rated=False, order_by=None):
film_ids = [f.id for f in films]
if user and user.is_authenticated():
profile = user.get_profile()
basket = BasketItem.user_basket(user)
rated_ids = Film._rated_film_ids(user)
if profile.recommendations_status in (profile.NORMAL_RECOMMENDATIONS, profile.FAST_RECOMMENDATIONS):
recommendations = _user_film_recommendations(user, film_ids)
else:
recommendations = {}
for f in films:
r = recommendations.get(f.id)
b = basket.get(f.id)
f._rated = f.id in rated_ids
f._guess_rating = r or 0
f._on_wishlist = b and b[0] and (b[0] != BasketItem.NOT_INTERESTED) or False
f._on_shitlist = b and (b[0] == BasketItem.NOT_INTERESTED) or False
else:
for f in films:
f._rated = False
f._guess_rating = 0
f._on_wishlist = False
f._on_shitlist = False
test_with_rated = lambda f: with_rated or not f._rated
films = list(f for f in films if not f._on_shitlist and test_with_rated(f))
comparator = create_film_comparator(order_by)
return sorted(films, cmp=comparator)
def show_event(request, permalink, ajax=None):
event = get_object_or_404(Event, permalink=permalink)
nominated = Nominated.objects.with_rates(event)
for n in nominated:
if n.film_id:
n.film = Film.get(id=n.film_id)
if n.person_id:
n.person = Person.get(id=n.person_id)
categories = []
for type, items in groupby(nominated, lambda n: n.oscar_type):
items = list(items)
if event.event_status == Event.STATUS_OPEN:
shuffle(list(items))
if items:
categories.append({
'name': items[0].get_category_name(),
'nominated': items,
})
ctx = {
'event': event,
'categories': categories,
}
return render_to_response('event/event.html',
ctx,
context_instance=RequestContext(request))
def get_films_to_rate(self, number_of_films=1, tag=None):
key = cache.Key("vue_rater_user_films", self.user)
user_films = cache.get(key)
if user_films is None:
user_films = vue.get_ordered_known_film_ids()
if self.SHUFFLE_BLOCK_SIZE:
shuffled = []
while user_films:
block = user_films[:self.SHUFFLE_BLOCK_SIZE]
user_films = user_films[self.SHUFFLE_BLOCK_SIZE:]
random.shuffle(block)
shuffled.extend(block)
user_films = shuffled
cache.set(key, user_films)
excluded = self.get_excluded_films()
out = []
for film_id in user_films:
if film_id not in excluded:
out.append(film_id)
if len(out) >= number_of_films:
break
out = [Film.get(id=id) for id in out]
return out
def show_event(request, permalink, ajax=None):
event = get_object_or_404(Event,permalink = permalink)
nominated = Nominated.objects.with_rates(event)
for n in nominated:
if n.film_id:
n.film = Film.get(id=n.film_id)
if n.person_id:
n.person = Person.get(id=n.person_id)
categories = []
for type, items in groupby(nominated, lambda n: n.oscar_type):
items = list(items)
if event.event_status == Event.STATUS_OPEN:
shuffle(list(items))
if items:
categories.append({
'name': items[0].get_category_name(),
'nominated': items,
})
ctx = {
'event': event,
'categories': categories,
}
return render_to_response('event/event.html', ctx, context_instance=RequestContext(request))
def get_excluded_films(self):
ids = set()
ids.update(self.get_seen_films())
if self.user.id:
ids.update(Rating.get_user_ratings(self.user).keys())
ids.update(Film._marked_film_ids(self.user))
return ids
def get_films_to_rate(self, number_of_films=1, tag=None):
key = cache.Key("vue_rater_user_films", self.user)
user_films = cache.get(key)
if user_films is None:
user_films = vue.get_ordered_known_film_ids()
if self.SHUFFLE_BLOCK_SIZE:
shuffled = []
while user_films:
block = user_films[:self.SHUFFLE_BLOCK_SIZE]
user_films = user_films[self.SHUFFLE_BLOCK_SIZE:]
random.shuffle(block)
shuffled.extend(block)
user_films = shuffled
cache.set(key, user_films)
excluded = self.get_excluded_films()
out = []
for film_id in user_films:
if film_id not in excluded:
out.append(film_id)
if len(out) >= number_of_films:
break
out = [Film.get(id=id) for id in out]
return out
def random_film_to_rate(request):
"""
Widget for main page (for not logged in users)
displaying a film to rate, selected from
the list of 10 most popular films.
"""
user = request.user
if user.is_authenticated():
film = Film.get_next_film_to_rate(user)
else:
key = cache.Key("popular_films_list")
popular_films = cache.get(key)
if popular_films is None:
fhelper = FilmHelper()
lang = getattr(settings, 'LANGUAGE_CODE', 'en')
if lang == 'en':
popular_films = fhelper.get_popular_films(exclude_nonEnglish=True)
else:
popular_films = fhelper.get_popular_films()
cache.set(key, popular_films)
film = popular_films and random.choice(popular_films) or None
return {
'film': film,
}
def film_id_to_imdb_code(cls, film_id):
imdb_code = cls._imdb_code_cache.get(film_id)
if imdb_code is None:
film = Film.get(id=film_id)
imdb_code = film and film.imdb_code
if imdb_code:
cls._imdb_code_cache[film_id] = imdb_code
return imdb_code
def next_film_to_rate_url(user):
if settings.NEW_RATING_SYSTEM:
films = BasketsRatingHelper.get_films_to_rate(user, 1)
film = films and films[0] or None
else:
film = Film.get_next_film_to_rate(user)
if film:
return reverse('show_film', args=(film.permalink, ))
else:
return ''
def test_save_searchkeys(self):
"""
Test saving searchkeys for localized film
"""
self.film = Film()
self.film.title = u"Olympia - Fest der Schönheit"
self.film.type = Object.TYPE_FILM
self.film.permalink = "olympia-2-teil-fest-der-schoenheit"
self.film.release_year = 1938
self.film.save()
fetch_synopses_for_films([
self.film,
], fetcher="tmdb")
loc_film = FilmLocalized.objects.all()[0]
self.assertEquals(loc_film.description is None, True)
self.assertEquals(loc_film.fetched_description is None, False)
def initialize(self):
self.clean_data()
# set up users
self.u1 = User.objects.create_user("michuk", "*****@*****.**", "secret")
self.u1.save()
self.u2 = User(username="******", email="*****@*****.**")
self.u2.save()
self.u3 = User(username="******", email="*****@*****.**")
self.u3.save()
self.u4 = User(username="******", email="*****@*****.**")
self.u4.save()
# set up film
self.film = Film()
self.film.title = "Battlefield Earth II"
self.film.type = Object.TYPE_FILM
self.film.permalink = "battlefirld-earth-ii"
self.film.release_year = 2010
self.film.save()
self.film.save_tags("comedy")
self.film1 = Film()
self.film1.title = "Battlefield Earth III"
self.film1.type = Object.TYPE_FILM
self.film1.permalink = "battlefirld-earth-iii"
self.film1.release_year = 2010
self.film1.save()
self.film1.save_tags("sci-fi")
self.film2 = Film()
self.film2.title = "Battlefield Earth IV"
self.film2.type = Object.TYPE_FILM
self.film2.permalink = "battlefirld-earth-iv"
self.film2.release_year = 2010
self.film2.save()
self.film2.save_tags("horror")
rating_helper.rate(self.u1, 8, self.film.id)
rating_helper.rate(self.u1, 8, self.film1.id)
rating_helper.rate(self.u1, 8, self.film2.id)
rating_helper.rate(self.u2, 8, self.film2.id, _skip_activity=True)
class RequestTestCase(TestCase):
fixtures = ['test_users.json']
def setUp(self):
self.user = User.objects.get(username='******')
self.user.set_password('bob')
self.user.save()
self.film = Film(type=1, permalink='przypadek', imdb_code=111, status=1, version=1,
release_year=1999, title='Przypadek', popularity=1, popularity_month=1)
self.film.save()
self.person = Person(type=2, permalink='jerzy-stuhr', imdb_code=112, status=1, version=1,
name='Jerzy', surname='Stuhr')
self.person.save()
def test_index(self):
response = self.client.get('/')
self.failUnlessEqual(response.status_code, 200)
def test_film(self):
response = self.client.get('/film/przypadek/')
self.failUnlessEqual(response.status_code, 200)
def test_film_authorized(self):
self.client.login(username='******', password='******')
response = self.client.get('/film/przypadek/')
self.assertTrue(response.context['request'].user.is_authenticated())
self.failUnlessEqual(response.status_code, 200)
def test_person(self):
response = self.client.get(self.person.get_absolute_url())
self.assertEquals(response.status_code, 200)
def test_person_authorized(self):
self.client.login(username='******', password='******')
response = self.client.get(self.person.get_absolute_url())
self.assertEquals(response.status_code, 200)
def tearDown(self):
Person.objects.all().delete()
Film.objects.all().delete()
def setUp( self ):
self.u1 = User.objects.create_user( "user1", "*****@*****.**", "user" )
self.u2 = User.objects.create_user( "user2", "*****@*****.**", "user" )
self.u3 = User.objects.create_user( "user3", "*****@*****.**", "user" )
self.f1 = Film()
self.f1.title = "Battlefield Earth"
self.f1.type = Film.TYPE_FILM
self.f1.permalink = "battlefirld-earth"
self.f1.release_year = 208
self.f1.production_country_list = "USA"
self.f1.save()
self.f2 = Film()
self.f2.title = "Battlefield Earth II"
self.f2.type = Film.TYPE_FILM
self.f2.permalink = "battlefirld-earth-ii"
self.f2.release_year = 2010
self.f2.production_country_list = "USA"
self.f2.save()
def setUp(self):
self.u1 = User.objects.create_user("user1", "*****@*****.**", "user")
self.u2 = User.objects.create_user("user2", "*****@*****.**", "user")
self.u3 = User.objects.create_user("user3", "*****@*****.**", "user")
self.f1 = Film()
self.f1.title = "Battlefield Earth"
self.f1.type = Film.TYPE_FILM
self.f1.permalink = "battlefirld-earth"
self.f1.release_year = 208
self.f1.production_country_list = "USA"
self.f1.save()
self.f2 = Film()
self.f2.title = "Battlefield Earth II"
self.f2.type = Film.TYPE_FILM
self.f2.permalink = "battlefirld-earth-ii"
self.f2.release_year = 2010
self.f2.production_country_list = "USA"
self.f2.save()
def setUp(self):
# set up users
self.u1= User.objects.create_user('michuk', '*****@*****.**', 'secret')
self.u1.save()
# set up film
self.film = Film()
self.film.title = "Battlefield Earth II"
self.film.type = Object.TYPE_FILM
self.film.permalink = "battlefirld-earth-ii"
self.film.release_year = 2010
self.film.save(saved_by=2)
def setUp(self):
self.user = User.objects.get(username='******')
self.user.set_password('bob')
self.user.save()
self.film = Film(type=1, permalink='przypadek', imdb_code=111, status=1, version=1,
release_year=1999, title='Przypadek', popularity=1, popularity_month=1)
self.film.save()
self.person = Person(type=2, permalink='jerzy-stuhr', imdb_code=112, status=1, version=1,
name='Jerzy', surname='Stuhr')
self.person.save()
def force_similar(self, recommendations, ratings):
if self.limit is not None and self.limit < TOP_RECOMMENDATIONS_NR:
similar_cnt = self.limit - (self.limit / 2)
else:
similar_cnt = 3
similar_films = get_similar_films()
similar_scores = {}
for film_id, r in ratings.items():
weight = r - 5
similar = similar_films.get(film_id, set())
for s_id in similar:
similar_scores[s_id] = similar_scores.get(s_id, 0) + weight
recommended_ids = set(k for k, v in recommendations)
similar_scores = [(id,
score * 10 + self.recommendations_dict.get(id, 0))
for (id, score) in similar_scores.items()]
top_similar = sorted(similar_scores, key=lambda i: i[1], reverse=True)
if settings.VUE_DEBUG:
self.similar_debug = [(Film.get(id=id), score)
for (id, score) in top_similar
if id in recommended_ids]
logger.info(self.similar_debug)
else:
self.similar_debug = []
top_similar = [(id, self.recommendations_dict.get(id, 0))
for (id, score) in top_similar
if score >= 0 and id in recommended_ids]
top_similar = top_similar[:similar_cnt]
self.similar = set(i[0] for i in top_similar)
recommendations = [
r for r in recommendations if r[0] not in self.similar
]
if len(top_similar) < (self.limit or TOP_RECOMMENDATIONS_NR):
# sort visible recommendations
left = (self.limit or TOP_RECOMMENDATIONS_NR) - len(top_similar)
top_similar.extend(recommendations[:left])
del recommendations[:left]
top_similar.sort(key=lambda r: r[1], reverse=True)
top_similar.extend(recommendations)
recommendations = top_similar
return recommendations
def setUp( self ):
# set up films
self.film1 = Film()
self.film1.title = "Film 1"
self.film1.type = Object.TYPE_FILM
self.film1.permalink = "film-1"
self.film1.release_year = 2010
self.film1.production_country_list = "USA"
self.film1.save()
self.film1.save_tags( "dramat komedia ", LANG="pl", saved_by=2 )
self.film1.save_tags( "drama comedy wizards ", LANG="en", saved_by=2 )
def test_watching_notification(self):
"""
Testing notifications for different types of activities (posts, short reviews and threads)
"""
self.initialize()
activity = UserActivity.objects.get_for_object(self.post1)
# create two comments for blog post by two different users
t = ThreadedComment(user=self.u2,
comment="This is a comment",
content_object=activity,
type=Object.TYPE_COMMENT)
t.save()
t = ThreadedComment(user=self.u3,
comment="This is also a comment",
content_object=activity,
type=Object.TYPE_COMMENT)
t.save()
# create film and a short review and a comment to it
f1 = Film(type=1, permalink='przypadek', imdb_code=111, status=1, version=1,
release_year=1999, title='Przypadek', popularity=1, popularity_month=1)
f1.save()
sr = ShortReview(user=self.u1, review_text="This is a short review", object = f1, type=Object.TYPE_SHORT_REVIEW)
sr.save()
activity2 = UserActivity.objects.get_for_object(sr)
t = ThreadedComment(user=self.u2,
comment="This is a comment to a short review",
content_object=activity2,
type=Object.TYPE_COMMENT)
t.save()
# assert all is fine
watching_objects = Watching.objects.all()
self.assertEquals(len(watching_objects), 5) # number of unique comments in threads should be equal to watching objects
reply_notices = notification.Notice.objects.filter(notice_type__label='reply')
# TODO: uncommend and fix in http://jira.filmaster.org/browse/FLM-1116
self.assertEquals(len(reply_notices), 4) # number of notices
def setUp( self ):
super( TaggingToolsTestCase, self ).setUp()
# ..
self.admin = User.objects.create_user( "admin", "*****@*****.**", "admin" )
self.admin.is_superuser = True
self.admin.save()
self.client = Client( follow=True )
self.rename_tag = registry.get_by_name( 'rename-tag' )
self.alias_tag = registry.get_by_name( 'alias-tag' )
self.film1 = Film()
self.film1.title = "Battlefield Earth II"
self.film1.type = Object.TYPE_FILM
self.film1.permalink = "battlefirld-earth-ii"
self.film1.release_year = 2010
self.film1.production_country_list = "USA"
self.film1.save()
self.film1.save_tags( "komedia, kosmos, test" )
self.film2 = Film()
self.film2.title = "Battlefield Earth III"
self.film2.type = Object.TYPE_FILM
self.film2.permalink = "battlefirld-earth-iii"
self.film2.release_year = 2011
self.film2.production_country_list = "USA"
self.film2.save()
self.film2.save_tags( "komedia, kosmos, test" )
self.film3 = Film()
self.film3.title = "Battlefield Earth IV"
self.film3.type = Object.TYPE_FILM
self.film3.permalink = "battlefirld-earth-iv"
self.film3.release_year = 2012
self.film3.production_country_list = "Italy"
self.film3.save()
self.film3.save_tags( "komedia romantyczna, kosmos, test" )
self.tag1 = Tag.objects.create( name='ciekawy' )
def next_film_to_rate_url(context, user):
request = context['request']
if settings.NEW_RATING_SYSTEM:
rater = rating_helper.get_rater(request)
films = rater.get_films_to_rate(1)
film = films and films[0] or None
else:
film = Film.get_next_film_to_rate(user)
if film:
return film.get_absolute_path()
else:
return ''
def next_film_to_rate_url(context, user):
request = context['request']
if settings.NEW_RATING_SYSTEM:
rater = rating_helper.get_rater(request)
films = rater.get_films_to_rate(1)
film = films and films[0] or None
else:
film = Film.get_next_film_to_rate(user)
if film:
return film.get_absolute_path()
else:
return ''
def test_get_user_seen_films(self):
""" Tests storing rated and seen films in cache. """
films = Film.objects.all()
API_VERSION = "1.1"
username = self.user.username
put_url = "/api/" + API_VERSION + "/user/" + username + "/ratings/film/"
# We rate movies and check if they were added to seen_films
for film in films[:10]:
film_put_url = put_url + film.permalink + "/" + str(Rating.TYPE_FILM) + "/"
self.client.put(film_put_url, {'rating': 2})
# We check if the film was added to user_seen_films
seen_films = Film.get_user_seen_films(self.user)
self.assertTrue(film.id in seen_films)
# We mark movies as seen and check if they were added to seen_films
for film in films[10:20]:
film.mark_as_seen(self.user)
# We check if the film was added to user_seen_films
seen_films = Film.get_user_seen_films(self.user)
self.assertTrue(film.id in seen_films)
def test_get_user_seen_films(self):
""" Tests storing rated and seen films in cache. """
films = Film.objects.all()
API_VERSION = "1.1"
username = self.user.username
put_url = "/api/" + API_VERSION + "/user/" + username + "/ratings/film/"
# We rate movies and check if they were added to seen_films
for film in films[:10]:
film_put_url = put_url + film.permalink + "/" + str(Rating.TYPE_FILM) + "/"
self.client.put(film_put_url, {'rating': 2})
# We check if the film was added to user_seen_films
seen_films = Film.get_user_seen_films(self.user)
self.assertTrue(film.id in seen_films)
# We mark movies as seen and check if they were added to seen_films
for film in films[10:20]:
film.mark_as_seen(self.user)
# We check if the film was added to user_seen_films
seen_films = Film.get_user_seen_films(self.user)
self.assertTrue(film.id in seen_films)
class TmdbFetcherTestCase(TestCase):
def test_fetcher(self):
title = "The Terminator"
url = "http://www.themoviedb.org/movie/218"
year = 1984
synopsis = "In the post-apocalyptic future, reigning tyrannical supercomputers teleport a cyborg assassin known as the \"Terminator\" back to 1984 to snuff Sarah Connor, whose unborn son is destined to lead insurgents against 21st century mechanical hegemony. Meanwhile, the human-resistance movement dispatches a lone warrior to safeguard Sarah. Can he stop the virtually indestructible killing machine?"
fetcher = TmdbSynopsisFetcher()
urls = fetcher.get_movie_urls(title, year)
synopses = fetcher.get_movie_synopses(urls[0]['url'])
self.assertEquals(synopses[0]['synopsis'], synopsis)
self.assertEquals(synopses[0]['url'], url)
self.assertEquals(synopses[0]['author'], "TMDb")
self.assertEquals(synopses[0]['distributor'], False)
self.assertEquals(synopses[0]['title'], title)
def test_save_searchkeys(self):
"""
Test saving searchkeys for localized film
"""
self.film = Film()
self.film.title = u"Olympia - Fest der Schönheit"
self.film.type = Object.TYPE_FILM
self.film.permalink = "olympia-2-teil-fest-der-schoenheit"
self.film.release_year = 1938
self.film.save()
fetch_synopses_for_films([
self.film,
], fetcher="tmdb")
loc_film = FilmLocalized.objects.all()[0]
self.assertEquals(loc_film.description is None, True)
self.assertEquals(loc_film.fetched_description is None, False)
def rate_next_film(request, tag=None):
mark_prev_films_as_seen(request)
if settings.NEW_RATING_SYSTEM:
rater = rating_helper.get_rater(request)
films = rater.get_films_to_rate(1, tag)
else:
films = Film.get_films_to_rate(user, 1, tag)
return render(
request, "movies/rating/single_film_special.html", {
'film': films[0] if len(films) else None,
'tag': tag,
'rater': request.GET.get('rater'),
})
def setUp(self):
self.user = User.objects.get(username='******')
self.user.set_password('bob')
self.user.save()
self.film = Film(type=1,
permalink='przypadek',
imdb_code=111,
status=1,
version=1,
release_year=1999,
title='Przypadek',
popularity=1,
popularity_month=1)
self.film.save()
self.person = Person(type=2,
permalink='jerzy-stuhr',
imdb_code=112,
status=1,
version=1,
name='Jerzy',
surname='Stuhr')
self.person.save()
def testQueueCommand(self):
f = Film( type=1, permalink='przypadek', imdb_code=111, status=1, version=1, \
release_year=1999, title='Przypadek' )
f.save()
f.delete()
self.assertEqual(QueuedItem.objects.count(), 3)
call_command('update_index_queue')
self.assertEqual(QueuedItem.objects.count(), 1)
