def test_movie_with_cast(self): m = MovieFactory() for i in range(100): cast = CastFactory(movie=m) CastFactory(role=cast.role) query = ''' query Movie($id: ID!, $role: ID!) { movie(id: $id) { id cast(role: $role) { edges { node { name person { firstNameEn, lastNameEn } role { nameEn } } } } } } ''' with self.assertNumQueries(3): result = self.execute( query, dict(id=global_id(m), role=global_id(cast.role))) self.assertEqual(len(result['movie']['cast']['edges']), m.cast.filter(role=cast.role).count())
def test_movies_filter_by_m2m(self, model, node, fieldname): items = model.objects.all()[:2] item1, item2 = items for m in Person.objects.all()[:10]: getattr(m, fieldname).set(items) query = ''' query Persons($rels: [ID!]) { persons(%s: $rels) { edges { node { id } } } } ''' % fieldname # TODO: decrease number of queries by 1 with self.assertNumQueries(3): result = self.execute( query, dict( rels=[global_id(item1), global_id(item2)])) self.assert_count_equal(result['persons'], (Person.objects.filter(**{ fieldname: item1 }).filter(**{ fieldname: item2 }).count()))
def test_movies_filter_by_wrong_m2m(self): query = ''' query Movies($rels: [ID!]) { movies(countries: $rels) { edges { node { id } } } } ''' with self.assertRaises(AssertionError): self.execute(query, dict(rels=(global_id(Genre(id=1)), global_id(Country(id=1)))))
def test_search_query(self, factory, raw_search): instances, query_name = self.prepare_stuff(factory, raw_search) with self.assertNumQueries(2): result = self.execute(self.search_query % query_name, dict(search='term', order='')) self.assert_count_equal(result[query_name], 3) self.assertEqual(result[query_name]['edges'][0]['node']['id'], global_id(instances[0])) self.assertEqual(result[query_name]['edges'][1]['node']['id'], global_id(instances[1])) self.assertEqual(result[query_name]['edges'][2]['node']['id'], global_id(instances[2]))
def test_object_wikipedia_pages(self, factory, node): instance = factory() en = WikipediaPageFactory(content_object=instance, lang='en') ru = WikipediaPageFactory(content_object=instance, lang='ru') query_name = instance._meta.model_name query = ''' query Movie($id: ID!) { %s(id: $id) { id wikipedia { edges { node { title lang content } } } } } ''' % query_name with self.assertNumQueries(3): result = self.execute(query, dict(id=global_id(instance))) self.assertEqual(len(result[query_name]['wikipedia']['edges']), 2) self.assertEqual( result[query_name]['wikipedia']['edges'][0]['node']['title'], en.title) self.assertEqual( result[query_name]['wikipedia']['edges'][1]['node']['title'], ru.title)
def test_person(self): p = PersonFactory(gender=Gender.MALE) p_id = global_id(p) query = ''' query Person($id: ID!) { person(id: $id) { id, gender nameEn, firstNameEn, lastNameEn nameRu, firstNameRu, lastNameRu dateBirth, dateDeath country { nameEn } roles { nameEn } } } ''' with self.assertNumQueries(2): result = self.execute(query, dict(id=p_id)) self.assertEqual(result['person']['id'], p_id) self.assertEqual(result['person']['nameEn'], p.name_en) self.assertEqual(result['person']['nameRu'], p.name_ru) self.assertEqual(result['person']['gender'], Gender.MALE.name) self.assertEqual(result['person']['dateBirth'], p.date_birth.strftime('%Y-%m-%d')) self.assertEqual(result['person']['dateDeath'], p.date_death.strftime('%Y-%m-%d')) self.assertEqual(result['person']['country']['nameEn'], p.country.name_en) self.assertGreater(len(result['person']['roles']), 0) self.assert_m2m_rel(result['person']['roles'], p.roles)
def test_movie_with_related_sites(self): m = ImdbMovieFactory(movie=KinopoiskMovieFactory().movie).movie query = ''' query Movie($id: ID!) { movie(id: $id) { id imdb { id, rating, votes, url } kinopoisk { id, rating, votes, info, url } } } ''' with self.assertNumQueries(1): result = self.execute(query, dict(id=global_id(m))) self.assertEqual(result['movie']['imdb']['id'], m.imdb.id) self.assertEqual(result['movie']['imdb']['rating'], m.imdb.rating) self.assertEqual(result['movie']['imdb']['votes'], m.imdb.votes) self.assertEqual(result['movie']['imdb']['url'], m.imdb.url) self.assertEqual(result['movie']['kinopoisk']['id'], m.kinopoisk.id) self.assertEqual(result['movie']['kinopoisk']['rating'], m.kinopoisk.rating) self.assertEqual(result['movie']['kinopoisk']['votes'], m.kinopoisk.votes) self.assertEqual(result['movie']['kinopoisk']['info'], m.kinopoisk.info) self.assertEqual(result['movie']['kinopoisk']['url'], m.kinopoisk.url)
def test_me(self): self.user = self.create_user() with self.assertNumQueries(1): result = self.execute(self.me_query) self.assertEqual(result['me']['id'], global_id(self.user)) self.assertEqual(result['me']['username'], self.user.username) self.assertEqual(result['me']['email'], self.user.email) self.assertEqual(result['me']['firstName'], self.user.first_name) self.assertEqual(result['me']['lastName'], self.user.last_name)
def assert_user(self, result, user): user = User.objects.get(username=user.username) self.assertDictEqual( result, dict(id=global_id(user), username=user.username, email=user.email, firstName=user.first_name, lastName=user.last_name))
def test_object_relation_unauth(self, factory, node, codes): rel = self.create_relation(factory, **{code: True for code in codes}) query_name = rel.object._meta.model_name with self.assertNumQueries(1): result = self.execute( self.object_relation_query % self.get_object_vars(rel), dict(id=global_id(rel.object)), self.get_context()) self.assert_unauth_response_relation_and_counts( result[query_name]['relation'], result[query_name]['relationsCount'], rel, codes)
def test_search_query_with_order_specified(self, raw_search): instances, query_name = self.prepare_stuff(MovieFactory, raw_search) instances[0].year = 2002 instances[0].save() instances[1].year = 2003 instances[1].save() instances[2].year = 2001 instances[2].save() with self.assertNumQueries(2): result = self.execute(self.search_query % query_name, dict(search='term', order='year')) self.assert_count_equal(result[query_name], 3) self.assertEqual(result[query_name]['edges'][0]['node']['id'], global_id(instances[2])) self.assertEqual(result[query_name]['edges'][1]['node']['id'], global_id(instances[0])) self.assertEqual(result[query_name]['edges'][2]['node']['id'], global_id(instances[1]))
def test_object_no_relation(self, factory, node, relation): instance = factory() rel = relation(object=instance) query_name = instance._meta.model_name with self.assertNumQueries(2): result = self.execute( self.object_relation_query % self.get_object_vars(rel), dict(id=global_id(instance))) self.assert_response_relation_and_counts( result[query_name]['relation'], result[query_name]['relationsCount'], relation(), [])
def test_person_without_related_sites(self): p = PersonFactory() query = ''' query Person($id: ID!) { person(id: $id) { id imdb { id } kinopoisk { id, info } } } ''' with self.assertNumQueries(1): result = self.execute(query, dict(id=global_id(p))) self.assertEqual(result['person']['imdb'], None) self.assertEqual(result['person']['kinopoisk'], None)
def test_relate_first_time(self, factory, node, relation, codes, queries_count): instance = factory() rel = relation(object=instance) self.assertEqual(relation.objects.count(), 0) with self.assertNumQueries(9 + queries_count): result = self.execute( self.relate_mutation % self.get_relate_vars(rel), dict(id=global_id(instance), code='fav')) self.assert_response_relation_and_counts(result['relate']['relation'], result['relate']['count'], relation(), codes) self.assert_relation_and_counts(relation, instance, codes)
def test_movie_with_related_movie(self): m = MovieFactory(prequel_for=MovieFactory(), sequel_for=MovieFactory(), remake_for=MovieFactory()) m_id = global_id(m) prequel_id = global_id(m.prequel_for) sequel_id = global_id(m.sequel_for) remake_id = global_id(m.remake_for) query = ''' query Movie($id: ID!) { movie(id: $id) { id, year prequelFor { id, year } sequelFor { id, year } remakeFor { id, year } } } ''' with self.assertNumQueries(1): result = self.execute(query, dict(id=m_id)) self.assertEqual(result['movie']['id'], m_id) self.assertEqual(result['movie']['prequelFor']['id'], prequel_id) self.assertEqual(result['movie']['sequelFor']['id'], sequel_id) self.assertEqual(result['movie']['remakeFor']['id'], remake_id)
def test_movie_without_related_sites(self): m = MovieFactory() query = ''' query Movie($id: ID!) { movie(id: $id) { id imdb { id, rating, votes } kinopoisk { id, rating, votes, info } } } ''' with self.assertNumQueries(1): result = self.execute(query, dict(id=global_id(m))) self.assertEqual(result['movie']['imdb'], None) self.assertEqual(result['movie']['kinopoisk'], None)
def test_person_with_career(self): p = PersonFactory() for i in range(100): cast = CastFactory(person=p) CastFactory(role=cast.role) query = ''' query Person($id: ID!, $role: ID!) { person(id: $id) { id career(role: $role) { edges { node { name movie { titleEn } role { nameEn } } } } } } ''' with self.assertNumQueries(3): result = self.execute(query, dict(id=global_id(p), role=global_id(cast.role))) self.assertEqual(len(result['person']['career']['edges']), p.career.filter(role=cast.role).count())
def test_persons_query_filter_by_country(self): country = Person.objects.all()[0].country query = ''' query Persons($country: ID!) { persons(country: $country) { edges { node { id } } } } ''' with self.assertNumQueries(2): result = self.execute(query, dict(country=global_id(country))) self.assert_count_equal(result['persons'], Person.objects.filter(country=country).count())
def test_person_with_related_sites(self): p = ImdbPersonFactory(person=KinopoiskPersonFactory().person).person query = ''' query Person($id: ID!) { person(id: $id) { id imdb { id, url } kinopoisk { id, info, url } } } ''' with self.assertNumQueries(1): result = self.execute(query, dict(id=global_id(p))) self.assertEqual(result['person']['imdb']['id'], p.imdb.id) self.assertEqual(result['person']['imdb']['url'], p.imdb.url) self.assertEqual(result['person']['kinopoisk']['id'], p.kinopoisk.id) self.assertEqual(result['person']['kinopoisk']['info'], p.kinopoisk.info) self.assertEqual(result['person']['kinopoisk']['url'], p.kinopoisk.url)
def test_change_relation(self, factory, node, relation, codes, queries_count): fav_codes = codes + ['fav'] rel = self.create_relation(factory, **{code: True for code in fav_codes}) self.assertEqual(relation.objects.count(), 1) self.assert_relation(rel, fav_codes) with self.assertNumQueries(6 + queries_count): result = self.execute( self.relate_mutation % self.get_relate_vars(rel), dict(id=global_id(rel.object), code='fav')) self.assert_response_relation_and_counts(result['relate']['relation'], result['relate']['count'], rel, codes) self.assert_relation_and_counts(relation, rel.object, codes)
def test_movie_with_m2m(self): m = MovieFactory() query = ''' query Movie($id: ID!) { movie(id: $id) { id genres { nameEn } countries { nameEn } languages { nameEn } } } ''' with self.assertNumQueries(4): result = self.execute(query, dict(id=global_id(m))) self.assertGreater(len(result['movie']['genres']), 0) self.assertGreater(len(result['movie']['languages']), 0) self.assertGreater(len(result['movie']['countries']), 0) self.assert_m2m_rel(result['movie']['genres'], m.genres) self.assert_m2m_rel(result['movie']['languages'], m.languages) self.assert_m2m_rel(result['movie']['countries'], m.countries)
def resolve_id(self, info): return global_id(Language(id=self.pk))
def resolve_id(self, info): return global_id(Genre(id=self.pk))
def global_id(self): return global_id(self)
def resolve_id(self, info): return global_id(Country(id=self.pk))