def test_fields(self):
        """Ensure `fields` is passed to embedded documents."""
        class CompoundParentSerializer(DocumentSerializer):
            class Meta:
                model = CompoundParentDocument
                fields = (
                    'embedded_list',
                    'embedded_list.child.name',
                    'embedded_map',
                    'embedded_map.child.age',
                    'list_of_embedded_documents',
                    'list_of_embedded_documents.child.name')
                depth = 1

        expected = dedent("""
            CompoundParentSerializer():
                embedded_list = EmbeddedSerializer(many=True, required=False):
                    name = CharField(required=False)
                embedded_map = DictField(child=EmbeddedSerializer(required=False), required=False):
                    age = IntegerField(required=False)
                list_of_embedded_documents = EmbeddedSerializer(many=True, required=False):
                    name = CharField(required=False)
        """)

        serializer = CompoundParentSerializer()
        unicode_repr(serializer)

        assert unicode_repr(CompoundParentSerializer()) == expected

    def test_nonPK_foreignkey_model_serializer(self):
        class TestParentModel(models.Model):
            title = models.CharField(max_length=64)

        class TestChildModel(models.Model):
            parent = models.ForeignKey(TestParentModel, related_name='children', on_delete=models.CASCADE)
            value = models.CharField(primary_key=True, max_length=64)

        class TestChildModelSerializer(serializers.ModelSerializer):
            class Meta:
                model = TestChildModel
                fields = ('value', 'parent')

        class TestParentModelSerializer(serializers.ModelSerializer):
            class Meta:
                model = TestParentModel
                fields = ('id', 'title', 'children')

        parent_expected = dedent("""
            TestParentModelSerializer():
                id = IntegerField(label='ID', read_only=True)
                title = CharField(max_length=64)
                children = PrimaryKeyRelatedField(many=True, queryset=TestChildModel.objects.all())
        """)
        self.assertEqual(unicode_repr(TestParentModelSerializer()), parent_expected)

        child_expected = dedent("""
            TestChildModelSerializer():
                value = CharField(max_length=64, validators=[<UniqueValidator(queryset=TestChildModel.objects.all())>])
                parent = PrimaryKeyRelatedField(queryset=TestParentModel.objects.all())
        """)
        self.assertEqual(unicode_repr(TestChildModelSerializer()), child_expected)

    def test_extra_kwargs_not_altered(self):
        class TestSerializer(serializers.ModelSerializer):
            non_model_field = serializers.CharField()

            class Meta:
                model = OneFieldModel
                read_only_fields = ('char_field', 'non_model_field')
                fields = read_only_fields
                extra_kwargs = {}

        class ChildSerializer(TestSerializer):
            class Meta(TestSerializer.Meta):
                read_only_fields = ()

        test_expected = dedent("""
            TestSerializer():
                char_field = CharField(read_only=True)
                non_model_field = CharField()
        """)

        child_expected = dedent("""
            ChildSerializer():
                char_field = CharField(max_length=100)
                non_model_field = CharField()
        """)
        self.assertEqual(unicode_repr(ChildSerializer()), child_expected)
        self.assertEqual(unicode_repr(TestSerializer()), test_expected)
        self.assertEqual(unicode_repr(ChildSerializer()), child_expected)

    def test_extra_field_kwargs(self):
        class CompoundParentSerializer(DocumentSerializer):
            class Meta:
                model = CompoundParentDocument
                fields = ('__all__')
                depth = 1
                extra_kwargs = {
                    'foo': {'default': 'bar'},
                    'embedded_list.child.name': {'default': 'Johnny'},
                    'list_of_embedded_documents.child.name': {'default': 'B'},
                    'embedded_map.child.name': {'default': 'Good'}
                }

        expected = dedent("""
            CompoundParentSerializer():
                id = ObjectIdField(read_only=True)
                foo = CharField(default='bar')
                embedded_list = EmbeddedSerializer(many=True, required=False):
                    name = CharField(default='Johnny')
                    age = IntegerField(required=False)
                list_of_embedded_documents = EmbeddedSerializer(many=True, required=False):
                    name = CharField(default='B')
                    age = IntegerField(required=False)
                embedded_map = DictField(child=EmbeddedSerializer(required=False), required=False):
                    name = CharField(default='Good')
                    age = IntegerField(required=False)
        """)

        assert unicode_repr(CompoundParentSerializer()) == expected

    def test_read_only(self):
        """Ensure `read_only` are passed to embedded documents."""
        class CompoundParentSerializer(DocumentSerializer):
            class Meta:
                model = CompoundParentDocument
                fields = ('__all__')
                read_only_fields = (
                    'foo',
                    'embedded_list.child.name',
                    'list_of_embedded_documents.child.name',
                    'embedded_map.child.name'
                )

        expected = dedent("""
            CompoundParentSerializer():
                id = ObjectIdField(read_only=True)
                foo = CharField(read_only=True)
                embedded_list = EmbeddedSerializer(many=True, required=False):
                    name = CharField(read_only=True)
                    age = IntegerField(required=False)
                list_of_embedded_documents = EmbeddedSerializer(many=True, required=False):
                    name = CharField(read_only=True)
                    age = IntegerField(required=False)
                embedded_map = DictField(child=EmbeddedSerializer(required=False), required=False):
                    name = CharField(read_only=True)
                    age = IntegerField(required=False)
        """)

        assert unicode_repr(CompoundParentSerializer()) == expected

    def test_nested_hyperlinked_relations(self):
        class TestSerializer(serializers.HyperlinkedModelSerializer):
            class Meta:
                model = RelationalModel
                depth = 1

        expected = dedent(
            """
            TestSerializer():
                url = HyperlinkedIdentityField(view_name='relationalmodel-detail')
                foreign_key = NestedSerializer(read_only=True):
                    url = HyperlinkedIdentityField(view_name='foreignkeytargetmodel-detail')
                    name = CharField(max_length=100)
                one_to_one = NestedSerializer(read_only=True):
                    url = HyperlinkedIdentityField(view_name='onetoonetargetmodel-detail')
                    name = CharField(max_length=100)
                many_to_many = NestedSerializer(many=True, read_only=True):
                    url = HyperlinkedIdentityField(view_name='manytomanytargetmodel-detail')
                    name = CharField(max_length=100)
                through = NestedSerializer(many=True, read_only=True):
                    url = HyperlinkedIdentityField(view_name='throughtargetmodel-detail')
                    name = CharField(max_length=100)
        """
        )
        self.assertEqual(unicode_repr(TestSerializer()), expected)

    def test_meta_exclude(self):
        """
        Serializer should respect Meta.exclude
        """
        class TestSerializer(DocumentSerializer):
            class Meta:
                model = RegularModel
                exclude = ('decimal_field', 'custom_field')
        expected = dedent("""
            TestSerializer():
                id = ObjectIdField(read_only=True)
                str_field = CharField(required=False)
                url_field = URLField(required=False)
                email_field = EmailField(required=False)
                int_field = IntegerField(required=False)
                long_field = IntegerField(required=False)
                float_field = FloatField(required=False)
                boolean_field = BooleanField(required=False)
                nullboolean_field = NullBooleanField(required=False)
                date_field = DateTimeField(required=False)
                complexdate_field = DateTimeField(required=False)
                uuid_field = UUIDField(required=False)
                id_field = ObjectIdField(required=False)
        """)

        self.assertEqual(unicode_repr(TestSerializer()), expected)

    def test_meta_exclude(self):
        """
        Serializer should respect Meta.exclude
        """
        class TestSerializer(DocumentSerializer):
            class Meta:
                model = RegularModel
                exclude = ('decimal_field', 'custom_field')

        # in pythons 2 and 3 regex reprs are different
        if six.PY2:
            regex_repr = "<_sre.SRE_Pattern object>"
        else:
            regex_repr = "re.compile('^valid_regex')"

        expected = dedent("""
            TestSerializer():
                id = ObjectIdField(read_only=True)
                str_field = CharField(required=False)
                str_regex_field = RegexField(regex=%s, required=False)
                url_field = URLField(required=False)
                email_field = EmailField(required=False)
                int_field = IntegerField(required=False)
                long_field = IntegerField(required=False)
                float_field = FloatField(required=False)
                boolean_field = BooleanField(required=False)
                nullboolean_field = NullBooleanField(required=False)
                date_field = DateTimeField(required=False)
                complexdate_field = DateTimeField(required=False)
                uuid_field = UUIDField(required=False)
                id_field = ObjectIdField(required=False)
        """ % regex_repr)

        assert unicode_repr(TestSerializer()) == expected

    def test_field_options(self):
        class TestSerializer(serializers.ModelSerializer):
            class Meta:
                model = FieldOptionsModel
                fields = '__all__'

        expected = dedent("""
            TestSerializer():
                id = IntegerField(label='ID', read_only=True)
                value_limit_field = IntegerField(max_value=10, min_value=1)
                length_limit_field = CharField(max_length=12, min_length=3)
                blank_field = CharField(allow_blank=True, max_length=10, required=False)
                null_field = IntegerField(allow_null=True, required=False)
                default_field = IntegerField(required=False)
                descriptive_field = IntegerField(help_text='Some help text', label='A label')
                choices_field = ChoiceField(choices=(('red', 'Red'), ('blue', 'Blue'), ('green', 'Green')))
        """)
        if six.PY2:
            # This particular case is too awkward to resolve fully across
            # both py2 and py3.
            expected = expected.replace(
                "('red', 'Red'), ('blue', 'Blue'), ('green', 'Green')",
                "(u'red', u'Red'), (u'blue', u'Blue'), (u'green', u'Green')"
            )
        self.assertEqual(unicode_repr(TestSerializer()), expected)

    def test_nested_unique_together_relations(self):
        class TestSerializer(serializers.HyperlinkedModelSerializer):
            class Meta:
                model = UniqueTogetherModel
                depth = 1
                fields = '__all__'

        expected = dedent("""
            TestSerializer():
                url = HyperlinkedIdentityField(view_name='uniquetogethermodel-detail')
                foreign_key = NestedSerializer(read_only=True):
                    url = HyperlinkedIdentityField(view_name='foreignkeytargetmodel-detail')
                    name = CharField(max_length=100)
                one_to_one = NestedSerializer(read_only=True):
                    url = HyperlinkedIdentityField(view_name='onetoonetargetmodel-detail')
                    name = CharField(max_length=100)
        """)
        if six.PY2:
            # This case is also too awkward to resolve fully across both py2
            # and py3.  (See above)
            expected = expected.replace(
                "('foreign_key', 'one_to_one')",
                "(u'foreign_key', u'one_to_one')"
            )
        self.assertEqual(unicode_repr(TestSerializer()), expected)

def smart_repr(value):
    if isinstance(value, QuerySet):
        return manager_repr(value)

    if isinstance(value, BaseField):
        return mongo_field_repr(value)

    if isinstance(value, BaseDocument):
        return mongo_field_repr(value)

    if isinstance(value, Field):
        return field_repr(value)

    value = unicode_repr(value)

    # Representations like u'help text'
    # should simply be presented as 'help text'
    value = uni_lit_re.sub("'\\1'", value)

    # Representations like
    # <django.core.validators.RegexValidator object at 0x1047af050>
    # Should be presented as
    # <django.core.validators.RegexValidator object>
    value = re.sub(' at 0x[0-9a-f]{4,32}>', '>', value)

    return value

    def test_regular_fields(self):
        """
        Model fields should map to their equivelent serializer fields.
        """
        class TestSerializer(serializers.ModelSerializer):
            class Meta:
                model = RegularFieldsModel
                fields = '__all__'

        expected = dedent("""
            TestSerializer():
                auto_field = IntegerField(read_only=True)
                big_integer_field = IntegerField()
                boolean_field = BooleanField(required=False)
                char_field = CharField(max_length=100)
                comma_separated_integer_field = CharField(max_length=100, validators=[<django.core.validators.RegexValidator object>])
                date_field = DateField()
                datetime_field = DateTimeField()
                decimal_field = DecimalField(decimal_places=1, max_digits=3)
                email_field = EmailField(max_length=100)
                float_field = FloatField()
                integer_field = IntegerField()
                null_boolean_field = NullBooleanField(required=False)
                positive_integer_field = IntegerField()
                positive_small_integer_field = IntegerField()
                slug_field = SlugField(max_length=100)
                small_integer_field = IntegerField()
                text_field = CharField(max_length=100, style={'base_template': 'textarea.html'})
                time_field = TimeField()
                url_field = URLField(max_length=100)
                custom_field = ModelField(model_field=<tests.test_model_serializer.CustomField: custom_field>)
                file_path_field = FilePathField(path='/tmp/')
        """)

        self.assertEqual(unicode_repr(TestSerializer()), expected)

    def test_field_options(self):
        class TestSerializer(DocumentSerializer):
            class Meta:
                model = FieldOptionsModel
                fields = "__all__"

        expected = dedent(
            """
            TestSerializer():
                id = ObjectIdField(read_only=True)
                required_field = IntegerField(required=True)
                int_null_field = IntegerField(allow_null=True, required=False)
                string_null_field = CharField(allow_blank=True, allow_null=True, required=False)
                required_list_field = ListField(allow_empty=False, child=IntegerField(required=False), required=True)
                non_required_list_field = ListField(child=IntegerField(required=False), required=False)
                required_dict_field = DictField(allow_empty=False, required=True)
                choices_field = ChoiceField(choices=(('red', 'Red'), ('blue', 'Blue'), ('green', 'Green')), required=False)
                length_limit_field = CharField(max_length=12, min_length=3, required=False)
                value_limit_field = IntegerField(max_value=12, min_value=3, required=False)
                decimal_field = DecimalField(decimal_places=4, max_digits=8, max_value=9999, required=False)
        """
        )
        # if six.PY2:
        #     # This particular case is too awkward to resolve fully across
        #     # both py2 and py3.
        #     expected = expected.replace(
        #         "('red', 'Red'), ('blue', 'Blue'), ('green', 'Green')",
        #         "(u'red', u'Red'), (u'blue', u'Blue'), (u'green', u'Green')"
        #     )
        assert unicode_repr(TestSerializer()) == expected

    def test_regular_fields(self):
        """
        Model fields should map to their equivelent serializer fields.
        """
        class TestSerializer(DocumentSerializer):
            class Meta:
                model = RegularModel

        expected = dedent("""
            TestSerializer():
                id = ObjectIdField(read_only=True)
                str_field = CharField(required=False)
                url_field = URLField(required=False)
                email_field = EmailField(required=False)
                int_field = IntegerField(required=False)
                long_field = IntegerField(required=False)
                float_field = FloatField(required=False)
                boolean_field = BooleanField(required=False)
                nullboolean_field = NullBooleanField(required=False)
                date_field = DateTimeField(required=False)
                complexdate_field = DateTimeField(required=False)
                uuid_field = UUIDField(required=False)
                id_field = ObjectIdField(required=False)
                decimal_field = DecimalField(decimal_places=2, max_digits=65536, required=False)
                custom_field = DocumentField(model_field=<tests.test_1basic.CustomField: custom_field>, required=False)
        """)

        self.assertEqual(unicode_repr(TestSerializer()), expected)

    def test_nested_hyperlinked_relations_starred_source(self):
        class TestSerializer(serializers.HyperlinkedModelSerializer):
            class Meta:
                model = RelationalModel
                depth = 1
                fields = '__all__'

                extra_kwargs = {
                    'url': {
                        'source': '*',
                    }}

        expected = dedent("""
            TestSerializer():
                url = HyperlinkedIdentityField(source='*', view_name='relationalmodel-detail')
                foreign_key = NestedSerializer(read_only=True):
                    url = HyperlinkedIdentityField(view_name='foreignkeytargetmodel-detail')
                    name = CharField(max_length=100)
                one_to_one = NestedSerializer(read_only=True):
                    url = HyperlinkedIdentityField(view_name='onetoonetargetmodel-detail')
                    name = CharField(max_length=100)
                many_to_many = NestedSerializer(many=True, read_only=True):
                    url = HyperlinkedIdentityField(view_name='manytomanytargetmodel-detail')
                    name = CharField(max_length=100)
                through = NestedSerializer(many=True, read_only=True):
                    url = HyperlinkedIdentityField(view_name='throughtargetmodel-detail')
                    name = CharField(max_length=100)
        """)
        self.maxDiff = None
        self.assertEqual(unicode_repr(TestSerializer()), expected)

    def test_nested_relations(self):
        class TestSerializer(serializers.ModelSerializer):
            class Meta:
                model = RelationalModel
                depth = 1
                fields = "__all__"

        expected = dedent(
            """
            TestSerializer():
                id = IntegerField(label='ID', read_only=True)
                foreign_key = NestedSerializer(read_only=True):
                    id = IntegerField(label='ID', read_only=True)
                    name = CharField(max_length=100)
                one_to_one = NestedSerializer(read_only=True):
                    id = IntegerField(label='ID', read_only=True)
                    name = CharField(max_length=100)
                many_to_many = NestedSerializer(many=True, read_only=True):
                    id = IntegerField(label='ID', read_only=True)
                    name = CharField(max_length=100)
                through = NestedSerializer(many=True, read_only=True):
                    id = IntegerField(label='ID', read_only=True)
                    name = CharField(max_length=100)
        """
        )
        self.assertEqual(unicode_repr(TestSerializer()), expected)

    def test_mapping(self):
        expected = dedent("""
            TestSerializer():
                id = ObjectIdField(read_only=True)
                fil = FileField(required=False)
        """)

        self.assertEqual(unicode_repr(TestSerializer()), expected)

 def test_embedded_serializer(self):
     class TestSerializer(EmbeddedDocumentSerializer):
         class Meta:
             model = EmbeddedModel
     expected = dedent("""
         TestSerializer():
             foo = CharField(required=False)
             bar = CharField(required=False)
     """)
     self.assertEqual(unicode_repr(TestSerializer()), expected)

 def test_embbedded(self):
     class EmbeddingSerializer(EmbeddedDocumentSerializer):
         class Meta:
             model = DumbEmbedded
     expected = dedent("""
         EmbeddingSerializer():
             name = CharField(required=False)
             foo = IntegerField(required=False)
     """)
     assert unicode_repr(EmbeddingSerializer()) == expected

    def test_embedding_generic(self):
        class EmbeddingSerializer(DocumentSerializer):
            class Meta:
                model = GenericEmbeddingDoc

        expected = dedent("""
            EmbeddingSerializer():
                id = ObjectIdField(read_only=True)
                embedded = GenericEmbeddedDocumentField(model_field=<mongoengine.fields.GenericEmbeddedDocumentField: embedded>, required=False)
        """)
        assert unicode_repr(EmbeddingSerializer()) == expected