def test_save_movie_relations_with_partially_missing(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
movie = MovieFactory(mid='tt0111161')
genres = ['drama', 'comedy', 'thriller']
key = Movie.make_key(provider=provider, id=movie.imdb_id)
related_key = '%s:related' % key
genres_key = '%s:genres' % key
self.db.session.commit()
for i in xrange(10):
movie_id = 'tt%s' % int(random.random() * 1000000)
movie_key = Movie.make_key(provider=provider, id=movie_id)
self.redis.sadd(related_key, movie_key)
if i % 2:
MovieFactory(mid=movie_id)
self.db.session.commit()
for genre in genres:
g = GenreFactory(title=genre)
self.redis.sadd(genres_key, genre)
self.db.session.commit()
missing = movie.save_relations()
self.assertEqual(len(missing), 5)
self.assertTrue(self.redis.exists(related_key))
self.assertEqual(len(self.redis.smembers(related_key)), 5)
self.assertFalse(self.redis.exists(genres_key))
self.assertEqual(len(movie.related_movies), 5)
self.assertEqual(len(movie.genres), 3)
def test_save_movie_relations_without_missing(self):
provider = 'imdb'
movie_id = 'tt0111161'
with self.instance.test_request_context() as request:
movie = MovieFactory(mid=movie_id)
genres = ['drama', 'comedy', 'thriller']
key = Movie.make_key(provider=provider, id=movie.imdb_id)
related_key = '%s:related' % key
genres_key = '%s:genres' % key
self.db.session.commit()
self.redis.sadd(Movie.added_key, key)
for i in xrange(10):
mid = 'tt%s' % int(random.random() * 1000000)
movie_key = Movie.make_key(provider=provider, id=mid)
m = MovieFactory(mid=mid)
self.redis.sadd(related_key, movie_key)
self.db.session.commit()
for genre in genres:
g = GenreFactory(title=genre)
self.redis.sadd(genres_key, genre)
self.db.session.commit()
missing = save_relations(key=key, model=Movie)
movie = self.db.session.query(Movie).filter(
Movie.imdb_id == movie_id).one()
self.assertEqual(len(missing), 0)
self.assertFalse(self.redis.exists(related_key))
self.assertFalse(self.redis.exists(genres_key))
self.assertEqual(len(movie.related_movies), 10)
self.assertEqual(len(movie.genres), 3)
def test_push_to_queue(self):
with self.instance.test_request_context() as request:
key = 'movie:tt12345678:imdb'
result = Movie.push(key=key)
self.assertTrue(result)
self.assertEqual(len(self.redis.keys()), 1)
self.assertTrue(self.redis.exists(Movie.not_added_key))
self.assertEqual(self.redis.llen(Movie.not_added_key), 1)
self.assertEqual(self.redis.lpop(Movie.not_added_key), key)
key = 'movie:tt12345678'
result = Movie.push(key=key)
self.assertFalse(result)
self.assertFalse(self.redis.exists(Movie.not_added_key))
key = 'person:tt12345678:imdb'
result = Movie.push(key=key)
self.assertFalse(result)
self.assertFalse(self.redis.exists(Movie.not_added_key))
key = 'person:tt12345678:qwerty'
result = Movie.push(key=key)
self.assertFalse(result)
self.assertFalse(self.redis.exists(Movie.not_added_key))
def test_parse_key(self):
key = 'movie:tt12345678:imdb'
result = Movie.parse_key(key=key, make_parser=True)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], 'tt12345678')
self.assertTrue(isinstance(result[1], IMDBParser))
result = Movie.parse_key(key=key)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], 'tt12345678')
self.assertEqual(result[1], 'imdb')
key = 'tt12345678:imdb'
result = Movie.parse_key(key=key)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], None)
self.assertEqual(result[1], None)
key = 'person:tt12345678:imdb'
result = Movie.parse_key(key=key)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], None)
self.assertEqual(result[1], None)
key = 'movie_tt12345678_imdb'
result = Movie.parse_key(key=key)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], None)
self.assertEqual(result[1], None)
def test_add_already_existed_movie(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
movie = MovieFactory(mid='tt0111161')
key = Movie.make_key(provider=provider, id=movie.imdb_id)
self.db.session.commit()
self.redis.sadd(Movie.added_key, key)
result = Movie.add(keys=(key, ))
self.assertEqual(len(result), 1)
self.assertEqual(result[0], movie)
def mutate(root, info, input=None):
ok = True
actors = []
for actor_input in input.actors:
actor = Actor.objects.get(pk=actor_input.id)
if actor is None:
return CreateMovie(ok=False, movie=None)
actors.append(actor)
movie_instance = Movie(
title=input.title,
year=input.year
)
movie_instance.save()
movie_instance.actors.set(actors)
return CreateMovie(ok=ok, movie=movie_instance)
def test_validate_single_key(self):
key = 'movie:tt12345678:imdb'
result = Movie.validate_keys(keys=(key,))
self.assertEqual(len(result), 1)
self.assertTrue(key in result)
def test_group_keys_with_some_wrong_by_provider(self):
keys = ['movie:tt1234567890:imdb', 'movie:tt1234567891:imdb',
'movie:tt1234567892_imdb', 'movie:1234567893:imdb']
groups = Movie.group_keys_by_provider(keys=keys)
self.assertEqual(len(groups), 1)
self.assertEqual(len(groups[0]['keys']), 2)
self.assertEqual(groups[0]['parser'], None)
keys = ['movie:tt1234567890:imdb', 'movie:tt1234567891:imdb',
'movie:tt1234567892_imdb', 'movie:1234567893:imdb']
groups = Movie.group_keys_by_provider(keys=keys, make_parser=True)
self.assertEqual(len(groups), 1)
self.assertEqual(len(groups[0]['keys']), 2)
self.assertTrue(isinstance(groups[0]['parser'], IMDBParser))
def add(cls, **kwargs):
keys = kwargs.get('keys', [])
result = []
groups = cls.group_keys_by_person(keys=keys)
for group in groups:
movie_keys = group['movie_keys']
movies = Movie.add(keys=movie_keys)
movie_ids = set([m.id for m in movies])
existed = db.session.query(Watchlist, Watchlist.movie_id).filter(
Watchlist.user_id == group['user_id'],
Watchlist.movie_id.in_(movie_ids)).all()
result.extend([w for w, mid in existed])
movie_ids = movie_ids.difference(set([mid for w, mid in existed]))
for movie_id in movie_ids:
item = Watchlist(user_id=group['user_id'], movie_id=movie_id)
try:
db.session.add(item)
db.session.commit()
except IntegrityError:
db.session.rollback()
else:
result.append(item)
return result
def get(self):
args = parser.parse_args()
params = [
Movie.is_series == False
]
query = self.build_query()
query = query.filter(*params).order_by(Movie.imdb_rating.desc())
if args['limit']:
query = query.limit(args['limit'])
if args['offset']:
query = query.offset(args['offset'])
movies = query.all()
Movie.load_genres(movies)
Movie.load_related(movies)
return marshal(movies, self.fields)
def test_validate_multiple_keys(self):
keys = ['movie:tt1234567890:imdb', 'movie:tt1234567891:imdb',
'movie:tt1234567892:imdb', 'movie:tt1234567893:imdb']
result = Movie.validate_keys(keys=keys)
self.assertEqual(len(result), len(keys))
self.assertEqual(result, keys)
def test_add_single_movie_with_wrong_keys(self):
key = 'movie:tt0167260_imdb'
with self.instance.test_request_context() as request:
result = Movie.add(key=key)
self.assertEqual(result, [])
self.assertFalse(self.redis.exists(Movie.added_key))
self.assertFalse(self.redis.exists(key))
def test_push_multiple_keys_to_queue(self):
with self.instance.test_request_context() as request:
keys = ['movie:tt1234567890:imdb', 'movie:tt1234567891:imdb',
'movie:tt1234567892:imdb', 'movie:tt1234567893:imdb']
result = Movie.push(keys=keys)
self.assertTrue(result)
self.assertTrue(self.redis.exists(Movie.not_added_key))
self.assertEqual(self.redis.llen(Movie.not_added_key), len(keys))
def test_validate_single_wrong_key(self):
keys = ['movie:tt12345678_imdb', 'movie:tt12345678', 'tt1245678',
'person:tt123456:imdb', 'movie:1234567:imdb',
'movie:tt1234567:rutracker']
for key in keys:
result = Movie.validate_keys(keys=(key,))
self.assertEqual(len(result), 0)
self.assertFalse(key in result)
def test_validate_multiple_keys_with_some_wrong(self):
keys = ['movie:tt1234567890:imdb', 'movie:tt1234567891:imdb',
'movie:tt1234567892_imdb', 'movie:1234567893:imdb']
result = Movie.validate_keys(keys=keys)
self.assertEqual(len(result), 2)
self.assertTrue('movie:tt1234567890:imdb' in result)
self.assertTrue('movie:tt1234567891:imdb' in result)
self.assertFalse('movie:tt1234567892_imdb' in result)
self.assertFalse('movie:1234567893:imdb' in result)
def test_make_key(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
u = UserFactory(login='******', email='*****@*****.**')
m = MovieFactory()
self.db.session.commit()
mid = getattr(m, '%s_id' % provider)
movie_key = Movie.make_key(provider=provider, id=mid)
key = Watchlist.make_key(user_id=u.id, movie_key=movie_key)
self.assertEqual(key, ':'.join(('watchlist', str(u.id), movie_key)))
def add_to_watchlist(**kwargs):
logger = kwargs.get('logger', None)
keys = kwargs.get('keys', [])
provider = 'imdb' # TODO: fix this later
save_relations = kwargs.get('save_relations', False)
if logger:
logger.info('Adding movies to watchlist: start')
result = Watchlist.add(keys=keys)
if save_relations:
if logger:
logger.info('Adding movies to watchlist: save movies relations')
movie_ids = [w.movie_id for w in result]
movies = db.session.query(Movie).filter(Movie.id.in_(movie_ids)).all()
for movie in movies:
movie.save_poster(provider=provider, load_original=True)
missing_movies = movie.save_relations()
Movie.add(keys=missing_movies)
if logger:
logger.info('Adding movies to watchlist: end')
def test_pull_from_queue(self):
keys = ['movie:tt1234567890:imdb', 'movie:tt1234567891:imdb',
'movie:tt1234567892:imdb', 'movie:tt1234567893:imdb']
for key in keys:
self.redis.rpush(Movie.not_added_key, key)
result = Movie.pull(count=3)
self.assertEqual(len(result), 3)
self.assertEqual(self.redis.llen(Movie.not_added_key), 1)
keys = ['movie:tt1234567890:imdb', 'movie:tt1234567891:imdb',
'movie:tt1234567892:imdb', 'movie:tt1234567893:imdb']
self.redis.delete(Movie.not_added_key)
for key in keys:
self.redis.rpush(Movie.not_added_key, key)
result = Movie.pull(count=10)
self.assertEqual(len(result), 4)
self.assertEqual(self.redis.llen(Movie.not_added_key), 0)
result = Movie.pull(count='a')
self.assertFalse(result)
def test_add_single_movie(self):
key = 'movie:tt0167260:imdb'
related_key = '%s:related' % key
genres_key = '%s:genres' % key
with self.instance.test_request_context() as request:
result = Movie.add(key=key)
self.assertEqual(len(result), 1)
self.assertTrue(isinstance(result[0], Movie))
self.assertTrue(self.redis.exists(Movie.added_key))
self.assertTrue(self.redis.sismember(Movie.added_key, key))
self.assertFalse(self.redis.exists(key))
self.assertTrue(self.redis.exists(related_key))
self.assertTrue(self.redis.exists(genres_key))
def test_add_multiple_movies_with_some_wrong_keys(self):
normal_key = 'movie:tt1229238:imdb'
keys = ['movie:tt0167260_imdb', 'movie:tt1229238:imdb',
'imdb:tt1272878:imdb']
with self.instance.test_request_context() as request:
result = Movie.add(keys=keys)
self.assertEqual(len(result), 1)
self.assertTrue(self.redis.exists(Movie.added_key))
self.assertTrue(self.redis.sismember(Movie.added_key, normal_key))
related_key = '%s:related' % normal_key
genres_key = '%s:genres' % normal_key
self.assertFalse(self.redis.exists(normal_key))
self.assertTrue(self.redis.exists(related_key))
self.assertTrue(self.redis.exists(genres_key))
def test_add_multiple_movies(self):
keys = ['movie:tt0167260:imdb', 'movie:tt1229238:imdb',
'movie:tt1272878:imdb']
with self.instance.test_request_context() as request:
result = Movie.add(keys=keys)
self.assertEqual(len(result), len(keys))
self.assertTrue(self.redis.exists(Movie.added_key))
for key in keys:
related_key = '%s:related' % key
genres_key = '%s:genres' % key
self.assertTrue(self.redis.sismember(Movie.added_key, key))
self.assertFalse(self.redis.exists(key))
self.assertTrue(self.redis.exists(related_key))
self.assertTrue(self.redis.exists(genres_key))
def test_add_single_key_with_existed_movie(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
u = UserFactory()
m = MovieFactory()
self.db.session.commit()
mid = getattr(m, '%s_id' % provider)
movie_key = Movie.make_key(provider=provider, id=mid)
key = Watchlist.make_key(user_id=u.id, movie_key=movie_key)
result = Watchlist.add(keys=(key,))
self.assertEqual(len(result), 1)
self.assertTrue(isinstance(result[0], Watchlist))
self.assertEqual(result[0].status, Watchlist.PENDING_MOVIE)
def fill_queue_from_csv(logger, **kwargs):
user_id = str(kwargs.get('user_id'))
provider = kwargs.get('provider')
logger.info('Filling watchlist queue: start')
path = os.path.join(instance.config.get('MEDIA_ROOT'), 'watchlists',
user_id, '%s_watchlist.csv' % provider)
if os.path.exists(path):
with open(path, 'rb') as csvfile:
reader = csv.reader(csvfile)
for row in reader:
if not str(row[1]).startswith('tt'):
continue
key = Watchlist.make_key(
user_id, Movie.make_key(provider=provider, id=row[1]))
redis.lpush(Watchlist.watchlist_key, key)
logger.info('Filling watchlist queue: end')
else:
logger.info('Filling watchlist queue: watchlist file does not exists')
def test_add_already_existed_key(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
u = UserFactory()
m = MovieFactory()
self.db.session.commit()
mid = getattr(m, '%s_id' % provider)
movie_key = Movie.make_key(provider=provider, id=mid)
w = Watchlist(user_id=u.id, movie_id=m.id)
self.db.session.add(w)
self.db.session.commit()
key = Watchlist.make_key(user_id=u.id, movie_key=movie_key)
result = Watchlist.add(keys=(key,))
self.assertEqual(len(result), 1)
self.assertEqual(result[0].id, w.id)
def test_add_already_existed_key(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
u = UserFactory()
m = MovieFactory()
self.db.session.commit()
user_id = u.id
mid = getattr(m, '%s_id' % provider)
movie_key = Movie.make_key(provider=provider, id=mid)
w = Watchlist(user_id=u.id, movie_id=m.id)
self.db.session.add(w)
self.db.session.commit()
key = Watchlist.make_key(user_id=u.id, movie_key=movie_key)
add_to_watchlist(keys=(key,))
watchlist = self.db.session.query(Watchlist).filter(Watchlist.user_id == user_id).all()
self.assertEqual(len(watchlist), 1)
def test_parse_key(self):
provider = 'imdb'
with self.instance.test_request_context() as request:
u = UserFactory(login='******', email='*****@*****.**')
m = MovieFactory()
self.db.session.commit()
mid = getattr(m, '%s_id' % provider)
movie_key = Movie.make_key(provider=provider, id=mid)
key = 'watchlist:1:%s' % movie_key
result = Watchlist.parse_key(key)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], u.id)
self.assertEqual(result[1], movie_key)
key = 'watchlist_1_%s' % movie_key
result = Watchlist.parse_key(key)
self.assertEqual(len(result), 2)
self.assertEqual(result[0], None)
self.assertEqual(result[1], None)
def make_key(cls, user_id, movie_key):
valid = Movie.validate_keys(keys=(movie_key, ))
if valid:
return ':'.join(('watchlist', str(user_id), movie_key))
else:
return None
def test_group_empty_keys_list_by_provider(self):
keys = []
groups = Movie.group_keys_by_provider(keys=keys)
self.assertEqual(len(groups), 0)
def test_make_key(self):
key = Movie.make_key(id='tt12345678', provider='imdb')
self.assertEqual(key, 'movie:tt12345678:imdb')
