def test_list_reference_field(mock_person, mock_post, schema_builder):
post1 = mock_post(text="Hey Joe")
post2 = mock_post(text="Say my name")
post1.save()
post2.save()
mock_person(posts=[post1, post2]).save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
posts {
text
}
}
}""")
assert result.data == {
'person': {
'posts': [{
"text": post1.text
}, {
"text": post2.text
}]
}
}
def reference_field(f_name, mongo_field):
""" Generate a schema for RefereceField, or get a schema already done saved in _generated_schemas """
from graphene_mongodb import MongoSchema
document = mongo_field.document_type_obj # document that this ReferenceField references
schema = MongoSchema.get_or_generate_schema(document).schema
return graphene.Field(schema)
def test_endswith(schema_builder, mock_person_filled):
p = mock_person_filled()
p.save()
PersonSchema = MongoSchema(mock_person_filled)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(query('name_Endswith:"' + p.name[-1] + '"'))
assert result.data['person'].get('id') == str(p.id)
def test_in(schema_builder, mock_person_filled):
p = mock_person_filled()
p.save()
PersonSchema = MongoSchema(mock_person_filled)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(query('id_In:["' + str(p.id) + '"]'))
assert result.data['person'].get('id') == str(p.id)
def test_no_operator(schema_builder, mock_person_filled):
""" without operator we consider that is a string with an id """
p = mock_person_filled()
p.save()
PersonSchema = MongoSchema(mock_person_filled)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(query('id:"' + str(p.id) + '"'))
assert result.data['person'].get('id') == str(p.id)
def test_nin(schema_builder, mock_person_filled, mock_person):
p1 = mock_person_filled()
p2 = mock_person()
p1.save()
p2.save()
PersonSchema = MongoSchema(mock_person_filled)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(query('id_Nin:["' + str(p1.id) + '"]'))
assert result.data['person'].get('id') != str(p1.id)
assert result.data['person'].get('id') == str(p2.id)
def test_ne(schema_builder, mock_person_filled):
p = mock_person_filled()
p.save()
PersonSchema = MongoSchema(mock_person_filled)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(query('name_Ne:"Test"'))
assert result.data['person'].get('id') == str(p.id)
result = schema.execute(query('name_Ne:"' + p.name + '"'))
assert result.data['person'] is None
def test_iexact(schema_builder, mock_person_filled):
p = mock_person_filled()
p.save()
PersonSchema = MongoSchema(mock_person_filled)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(query('name_Iexact:"' + p.name.lower() + '"'))
assert result.data['person'].get('id') == str(p.id)
result = schema.execute(query('name_Iexact:"' + p.name.upper() + '"'))
assert result.data['person'].get('id') == str(p.id)
def test_exists(schema_builder, mock_person_filled):
p = mock_person_filled()
p.save()
PersonSchema = MongoSchema(mock_person_filled)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(query('name_Exists: true'))
assert result.data['person'].get('id') == str(p.id)
result = schema.execute(query('name_Exists: false'))
assert result.data['person'] is None
def test_contains(schema_builder, mock_person_filled):
p = mock_person_filled()
p.save()
PersonSchema = MongoSchema(mock_person_filled)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(query('name_Contains:"' + p.name[2:6] + '"'))
assert result.data['person'].get('id') == str(p.id)
result = schema.execute(
query('name_Contains:"' + p.name[2:6].upper() + '"'))
assert result.data['person'] is None
def test_size(schema_builder, mock_person_filled):
p = mock_person_filled()
p.save()
PersonSchema = MongoSchema(mock_person_filled)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(
query('favouriteColors_Size:{}'.format(len(p.favourite_colors))))
assert result.data['person'].get('id') == str(p.id)
result = schema.execute(query('favouriteColors_Size: 0'))
assert result.data['person'] is None
def test_email_field(mock_person, schema_builder):
p = mock_person(email="*****@*****.**")
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
email
}
}""")
assert result.data == {'person': {'email': p.email}}
def test_float_field(mock_person, schema_builder):
p = mock_person(score=9.5)
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
score
}
}""")
assert result.data == {'person': {'score': p.score}}
def test_int_field(mock_person, schema_builder):
p = mock_person(age=20)
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
age
}
}""")
assert result.data == {'person': {'age': p.age}}
def test_binary_field(mock_person, schema_builder):
p = mock_person(nickname=b"John armless")
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
nickname
}
}""")
assert result.data == {'person': {'nickname': p.nickname.decode('utf-8')}}
def test_boolean_field(mock_person, schema_builder):
p = mock_person(active=True)
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
active
}
}""")
assert result.data == {'person': {'active': p.active}}
def test_decimal_field(mock_person, schema_builder):
p = mock_person(remember_pi=3.14159265359)
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
rememberPi
}
}""")
assert result.data == {'person': {'rememberPi': float(p.remember_pi)}}
def test_id_field(mock_person, schema_builder):
p = mock_person()
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
id
}
}""")
assert result.data == {'person': {'id': str(p.id)}}
def test_list_field(mock_person, schema_builder):
p = mock_person(favourite_colors=['blue', 'red'])
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
favouriteColors
}
}""")
assert result.data == {'person': {'favouriteColors': p.favourite_colors}}
def test_string_field(schema_builder, mock_person):
p = mock_person(name="John")
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
name
}
}""")
assert not result.errors
assert result.data == {'person': {'name': p.name}}
def test_long_field(mock_person, schema_builder):
long = pow(2, 63) - 1
p = mock_person(super_id=long)
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
superId
}
}""")
assert result.data == {'person': {'superId': long}}
assert result.data == {'person': {'superId': p.super_id}}
def test_url_field(mock_person, schema_builder):
site_url = "https://github.com/joaovitorsilvestre/MongographQL"
p = mock_person(site_url=site_url)
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
siteUrl
}
}""")
assert result.data == {'person': {'siteUrl': p.site_url}}
assert result.data == {'person': {'siteUrl': site_url}}
def test_datetime_field(mock_person, schema_builder):
from datetime import datetime
birth = datetime(2017, 1, 1)
p = mock_person(birthday=birth).save()
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
birthday
}
}""")
assert result.data == {'person': {'birthday': birth.isoformat()}}
assert result.data == {'person': {'birthday': p.birthday.isoformat()}}
def test_dict_field(mock_person, schema_builder):
info = {"author": "João", "date": "2017-01-01"}
p = mock_person(book_info=info)
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
bookInfo
}
}""")
assert result.data == {'person': {'bookInfo': info}}
assert result.data == {'person': {'bookInfo': p.book_info}}
def test_reference_field(mock_person, mock_post, schema_builder):
post = mock_post(text="Hey Joe")
post.save()
mock_person(best_post=post).save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
bestPost {
text
}
}
}""")
assert result.data == {'person': {'bestPost': {'text': post.text}}}
def list_field(f_name, mongo_field):
from graphene_mongodb import MongoSchema
from graphene_mongodb.fields.respective import respective_fields
list_items_type = type(mongo_field.field)
if list_items_type in respective_fields:
return graphene.List(type(respective_fields[list_items_type]()))
else:
try:
document = mongo_field.field.document_type
except AttributeError:
raise AttributeError(
'Error in {} field, have sure that this is defined with a mongoengine field'
.format(f_name))
schema = MongoSchema.get_or_generate_schema(document).schema
return graphene.List(schema)
def test_skip_parameter(schema_builder, mock_person):
""" without operator we consider that is a string with an id """
persons = [mock_person(name=str(i)) for i in range(10)]
for p in persons:
p.save()
PersonSchemaList = MongoSchema(mock_person)
schema = schema_builder([(PersonSchemaList, PersonSchemaList.list)])
result = schema.execute(""" query testQuery {
person(skip: 5) {
name
}
}""")
assert isinstance(result.data['person'], list)
assert len(result.data['person']) == 5
for i, person in enumerate(result.data['person']):
assert person['name'] == persons[i + 5].name
def test_point_field(mock_person, schema_builder):
p = mock_person(location=[29.977291, 31.132493])
p.save()
PersonSchema = MongoSchema(mock_person)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(""" query testQuery {
person {
location
}
}""")
assert result.data == {
'person': {
'location': {
"type": "Point",
"coordinates": [29.977291, 31.132493]
}
}
}
def test_lte(schema_builder, mock_person_filled):
p = mock_person_filled()
p.save()
PersonSchema = MongoSchema(mock_person_filled)
schema = schema_builder([(PersonSchema, PersonSchema.single)])
result = schema.execute(
query('birthday_Lte:"' + p.birthday.isoformat() + '"'))
assert result.data['person'].get('id') == str(p.id)
result = schema.execute(
query('birthday_Lte:"' + (p.birthday + timedelta(days=1)).isoformat() +
'"'))
assert result.data['person'].get('id') == str(p.id)
result = schema.execute(
query('birthday_Lte:"' + (p.birthday - timedelta(days=1)).isoformat() +
'"'))
assert result.data['person'] is None
