Beispiel #1
0
    def test_fwd_relation_mapping(self, assert_dict_equals):
        """
        Confirm that the serializer still handles models which have
        relations to other models, w/o custom field selection
        """
        class TestSerializer(DjongoModelSerializer):
            class Meta:
                model = RelationContainerModel
                fields = '__all__'

        expected_dict = {
            '_id':
            rmd_fields.ObjectIdField(read_only=True),
            'control_val':
            drf_fields.CharField(max_length=10, required=False),
            'fk_field': ('PrimaryKeyRelatedField('
                         'queryset=ForeignKeyRelatedModel.objects.all())'),
            'mtm_field': ('ManyRelatedField(child_relation='
                          'PrimaryKeyRelatedField(queryset='
                          'ManyToManyRelatedModel.objects.all(), '
                          'required=False), '
                          'required=False)'),
        }

        assert_dict_equals(expected_dict, TestSerializer().get_fields())
Beispiel #2
0
    def test_inherited_field_nullable(self, assert_dict_equals):
        """
        Confirm that fields declared in a parent serializer can be set
        to null to ignore them in child serializers
        """
        class TestSerializer(DjongoModelSerializer):
            missing = PrimaryKeyRelatedField(
                queryset=RelationContainerModel.objects.all())

            class Meta:
                model = RelationContainerModel
                fields = '__all__'

        class ChildSerializer(TestSerializer):
            missing = None

            class Meta(TestSerializer.Meta):
                pass

        expected_dict = {
            '_id':
            rmd_fields.ObjectIdField(read_only=True),
            'control_val':
            drf_fields.CharField(max_length=10, required=False),
            'fk_field': ('PrimaryKeyRelatedField('
                         'queryset=ForeignKeyRelatedModel.objects.all())'),
            'mtm_field': ('ManyRelatedField(child_relation='
                          'PrimaryKeyRelatedField(queryset='
                          'ManyToManyRelatedModel.objects.all(), '
                          'required=False), '
                          'required=False)'),
        }

        assert_dict_equals(ChildSerializer().get_fields(), expected_dict)
Beispiel #3
0
    def test_respects_fields(self, assert_dict_equals):
        """
        Confirm that embedded models can be ignored by not specifying
        them in the `fields` Meta parameter
        """
        class TestSerializer(DjongoModelSerializer):
            class Meta:
                model = ContainerModel
                fields = ['_id']

        expected_dict = {
            '_id': rmd_fields.ObjectIdField(read_only=True),
        }

        assert_dict_equals(TestSerializer().get_fields(), expected_dict)
Beispiel #4
0
    def test_respects_exclude(self, assert_dict_equals):
        """
        Confirm that embedded models can be ignored by specifying them
        in the `exclude` Meta parameter
        """
        class TestSerializer(DjongoModelSerializer):
            class Meta:
                model = ContainerModel
                exclude = ['embed_field']

        expected_dict = {
            '_id': rmd_fields.ObjectIdField(read_only=True),
            'control_val': CharField(required=False, max_length=7)
        }

        assert_dict_equals(TestSerializer().get_fields(), expected_dict)
Beispiel #5
0
    def test_common_embed(self, assert_dict_equals):
        """
        Confirm that the serializer automatically generates embedded
        serializer fields if not otherwise specified. Confirm that this
        created serializer, by default, allows null values
        """
        class TestSerializer(DjongoModelSerializer):
            class Meta:
                model = ContainerModel
                fields = '__all__'

        class EmbeddedSerializer(EmbeddedModelSerializer):
            class Meta:
                model = EmbedModel
                fields = '__all__'

        expected_dict = {
            '_id': rmd_fields.ObjectIdField(read_only=True),
            'control_val': CharField(max_length=7, required=False),
            'embed_field': EmbeddedSerializer(allow_null=True, required=False)
        }

        assert_dict_equals(TestSerializer().get_fields(), expected_dict)