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