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