class User(Document):
    __collection__ = 'users'

    index = IntField(required=True)
    email = StringField(required=True)
    first_name = StringField(
        db_field="whatever", max_length=50, default=lambda: "Bernardo"
    )
    last_name = StringField(max_length=50, default="Heynemann")
    is_admin = BooleanField(default=True)
    website = URLField(default="http://google.com/")
    updated_at = DateTimeField(
        required=True, auto_now_on_insert=True, auto_now_on_update=True
    )
    embedded = EmbeddedDocumentField(
        EmbeddedDocument, db_field="embedded_document"
    )
    nullable = EmbeddedDocumentField(
        EmbeddedDocument, db_field="nullable_embedded_document"
    )
    numbers = ListField(IntField())

    posts = ListField(ReferenceField(reference_document_type=Post))

    def __repr__(self):
        return "%s %s <%s>" % (self.first_name, self.last_name, self.email)
示例#2
0
    def test_to_son(self):
        field = EmbeddedDocumentField(db_field="test",
                                      embedded_document_type=User)

        u = User(name="test")

        expect(field.to_son(u)).to_be_like({'name': 'test'})
示例#3
0
    def test_from_son(self):
        field = EmbeddedDocumentField(db_field="test",
                                      embedded_document_type=User)

        user = field.from_son({'name': 'test2'})

        expect(user).to_be_instance_of(User)
        expect(user.name).to_equal("test2")
    def test_to_son(self):
        field = EmbeddedDocumentField(db_field="test", embedded_document_type=User)

        u = User(name="test")

        expect(field.to_son(u)).to_be_like({
            'name': 'test'
        })
    def test_from_son(self):
        field = EmbeddedDocumentField(db_field="test", embedded_document_type=User)

        user = field.from_son({
            'name': 'test2'
        })

        expect(user).to_be_instance_of(User)
        expect(user.name).to_equal("test2")
    def test_to_son(self):
        field = EmbeddedDocumentField(db_field="test", embedded_document_type=User)

        u = User(name="test")

        expect(field.to_son(u)).to_be_like({
            '__module__': 'tests.fields.test_embedded_document_field',
            '__class__': 'User',
            'name': 'test'
        })
    def test_to_son(self):
        field = EmbeddedDocumentField(db_field="test",
                                      embedded_document_type=User)

        u = User(name="test")

        expect(field.to_son(u)).to_be_like({
            '__module__': 'tests.fields.test_embedded_document_field',
            '__class__': 'User',
            'name': 'test'
        })
    def test_from_son(self):
        field = EmbeddedDocumentField(db_field="test", embedded_document_type=User)

        user = field.from_son({
            '__module__': 'tests.fields.test_embedded_document_field',
            '__class__': 'User',
            'name': 'test2'
        })

        expect(user).to_be_instance_of(User)
        expect(user.name).to_equal("test2")
    def test_from_son(self):
        field = EmbeddedDocumentField(db_field="test",
                                      embedded_document_type=User)

        user = field.from_son({
            '__module__': 'tests.fields.test_embedded_document_field',
            '__class__': 'User',
            'name': 'test2'
        })

        expect(user).to_be_instance_of(User)
        expect(user.name).to_equal("test2")
    def test_validate_enforces_embedded_document_object(self):
        class Doc(Document):
            name = StringField()

        field = EmbeddedDocumentField(embedded_document_type=User)

        user = User(name='test')
        doc = Doc(name='test')

        expect(field.validate(user)).to_be_true()
        expect(field.validate(doc)).to_be_false()
        expect(field.validate(None)).to_be_true()
class Post(Document):
    __collection__ = 'posts'

    title = StringField(required=True)
    text = StringField(required=True, db_field='content')
    category = ReferenceField(reference_document_type=Category)
    comments = ListField(EmbeddedDocumentField(embedded_document_type=Comment))
示例#12
0
文件: fake.py 项目: dimonji/chimera
class FakeUserDocument(Document):
    __collection__ = "fakeUser"
    fake_id = StringField()
    info = EmbeddedDocumentField(FakeUserInfoDocument)
    critic = BaseField()
    cluster = StringField()

    def get_user_name(self) -> str:
        return self.info.name
 def test_cant_create_embedded_field_of_wrong_embedded_type(self):
     try:
         EmbeddedDocumentField(embedded_document_type=10).validate(None)
     except ValueError:
         err = sys.exc_info()[1]
         expect(err).to_have_an_error_message_of(
             "The field 'embedded_document_type' argument must be a subclass of Document, not '10'."
         )
     else:
         assert False, "Should not have gotten this far"
示例#14
0
class Lesson(Document):
    id = IntField()
    name = StringField(required=True)
    audience = StringField()
    teacher_name = StringField()
    lesson_type = StringField()
    start_time = StringField()
    color = StringField()
    comments = ListField(EmbeddedDocumentField(embedded_document_type=Comment))
    day = ReferenceField('DayTimetable')
    def test_validate(self):
        field = EmbeddedDocumentField(User)

        expect(field.validate(None)).to_be_true()
        expect(field.validate("String")).to_be_false()
        expect(field.validate(User())).to_be_true()
        expect(field.from_son(None)).to_be_null()
示例#16
0
class User(Document):
    def __init__(self, **kwargs):
        super(User, self).__init__(**kwargs)

    id = IntField(unique=True)
    email = EmailField()

    _salt = BinaryField(12)
    # 64 is the length of the SHA-256 encoded string length
    _password = StringField(64)

    group = ReferenceField('scheduler.model.Group')
    timetable = EmbeddedDocumentField('scheduler.model.Schedule')
class EmbeddedDocument(Document):
    test = StringField(db_field="other", required=True)
    embedded2 = EmbeddedDocumentField(EmbeddedDocument2)
示例#18
0
class University(Document):
    id = IntField()
    name = StringField(required=True)
    groups = ListField(EmbeddedDocumentField(Group()))
示例#19
0
class Group(Document):
    id = IntField()
    name = StringField(required=True)
    users = ListField(ReferenceField('User'))
    university = ReferenceField('University')
    timetable = EmbeddedDocumentField(Schedule())
示例#20
0
class Schedule(Document):
    days = ListField(EmbeddedDocumentField(DayTimetable()))
    user = ReferenceField(reference_document_type=User)
    group = ReferenceField('scheduler.model.Group')
    pass
示例#21
0
class DayTimetable(Document):
    name = StringField(required=True)
    lessons = ListField(EmbeddedDocumentField(Lesson()))
    schedule = ReferenceField('scheduler.model.Schedule')
示例#22
0
 class Doc(Document):
     embedded = EmbeddedDocumentField(
         embedded_document_type=Model, required=False
     )
示例#23
0
class User(Document):
    name = EmbeddedDocumentField(embedded_document_type=Name)
    email = StringField(db_field='email_address')
    numbers = ListField(base_field=IntField())
示例#24
0
 class Test(Document):
     __collection__ = "TestEmbeddedParent"
     test = EmbeddedDocumentField(TestEmbedded)
示例#25
0
class Post(Document):
    title = StringField(required=True)
    body = StringField(required=True)

    comments = ListField(EmbeddedDocumentField(Comment))
示例#26
0
class Action(Document):
    __collection__ = "actions"

    action_type = IntField(required=True)
    payload = EmbeddedDocumentField(embedded_document_type=Document)
示例#27
0
 class RawQueryDocument(Document):
     items = ListField(EmbeddedDocumentField(RawQueryEmbeddedDocument))
示例#28
0
 class ElemMatchEmbeddedParentDocument(Document):
     items = ListField(EmbeddedDocumentField(ElemMatchEmbeddedDocument))
示例#29
0
    def test_item_embedded_type(self):
        class OtherType(Document):
            pass

        field = ListField(EmbeddedDocumentField(OtherType))
        expect(field.item_type).to_equal(OtherType)
 def test_create_embedded_document_field(self):
     field = EmbeddedDocumentField(db_field="test",
                                   embedded_document_type=User)
     expect(field.db_field).to_equal("test")
     expect(field._embedded_document_type).to_equal(User)
示例#31
0
class EditPatientAction(Document):
    __collection__ = "edit_patient_actions"
    patientUid = UUIDField()
    new_first_name = StringField()
    new_last_name = StringField()
    contact_info = EmbeddedDocumentField(embedded_document_type=Document)
    def test_validate(self):
        field = EmbeddedDocumentField(User)

        expect(field.validate(None)).to_be_true()
        expect(field.validate("String")).to_be_false()
        expect(field.validate(User())).to_be_true()
 def test_create_embedded_document_field_with_string_type(self):
     field = EmbeddedDocumentField(
         embedded_document_type=
         "tests.fields.test_embedded_document_field.User")
     expect(field.embedded_type).to_equal(User)