django-pfx 1.4.dev144__tar.gz → 1.4.dev148__tar.gz

{django_pfx-1.4.dev144 → django_pfx-1.4.dev148}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-pfx
-Version: 1.4.dev144
+Version: 1.4.dev148
 Summary: Django PFX is a toolkit designed to streamline the development of RESTful APIs using the Django framework.
 Author: Hervé Martinet
 Author-email: herve.martinet@gmail.com

{django_pfx-1.4.dev144 → django_pfx-1.4.dev148}/django_pfx.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: django-pfx
-Version: 1.4.dev144
+Version: 1.4.dev148
 Summary: Django PFX is a toolkit designed to streamline the development of RESTful APIs using the Django framework.
 Author: Hervé Martinet
 Author-email: herve.martinet@gmail.com

{django_pfx-1.4.dev144 → django_pfx-1.4.dev148}/django_pfx.egg-info/SOURCES.txt

@@ -150,6 +150,7 @@ tests/tests/test_fields_date.py
 tests/tests/test_fields_decimal.py
 tests/tests/test_fields_minutes_duration.py
 tests/tests/test_fields_nh3.py
+tests/tests/test_fields_one2many.py
 tests/tests/test_filters.py
 tests/tests/test_locale_api.py
 tests/tests/test_ordered_rest_view_mixin.py

{django_pfx-1.4.dev144 → django_pfx-1.4.dev148}/pfx/pfxcore/locale/fr/LC_MESSAGES/django.po

@@ -7,7 +7,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: \n"
 "Report-Msgid-Bugs-To: \n"
-"POT-Creation-Date: 2025-09-09 10:06+0200\n"
+"POT-Creation-Date: 2025-09-15 14:06+0200\n"
 "PO-Revision-Date: 2021-06-22 23:31+0200\n"
 "Last-Translator: \n"
 "Language-Team: \n"
@@ -286,23 +286,23 @@ msgstr "Le paramètre object est requis pour move={move}."
 msgid "object {pk} does not exists in this move context."
 msgstr "object {pk} n'existe pas dans ce contexte de déplacement."
 
-#: views/rest_views.py:234
+#: views/rest_views.py:220
 #, python-brace-format
 msgid "{obj} cannot be deleted because it is referenced by other objects."
 msgstr ""
 "{obj} ne peut pas être supprimé car il est référencé par d’autres objets."
 
-#: views/rest_views.py:331
+#: views/rest_views.py:344
 #, python-brace-format
 msgid "{model} {obj} created."
 msgstr "{model} {obj} créé."
 
-#: views/rest_views.py:332
+#: views/rest_views.py:345
 #, python-brace-format
 msgid "{model} {obj} updated."
 msgstr "{model} {obj} modifié."
 
-#: views/rest_views.py:1184
+#: views/rest_views.py:1217
 #, python-brace-format
 msgid "{model} {obj} deleted."
 msgstr "{model} {obj} supprimé."

{django_pfx-1.4.dev144 → django_pfx-1.4.dev148}/pfx/pfxcore/models/pfx_models.py

@@ -29,6 +29,7 @@ class JSONReprMixin():
 
     def __init__(self, *args, **kw):
         super().__init__(*args, **kw)
+        self._rel_data = {}
         self._after_save = []
 
     def get_url(self):

{django_pfx-1.4.dev144 → django_pfx-1.4.dev148}/pfx/pfxcore/views/fields.py

@@ -93,12 +93,23 @@ class FieldType:
         return cls.APIDOC_FIELD_BINDING.get(field_type)
 
 
+def get_db_type(field):
+    if isinstance(field, models.ManyToManyRel):
+        return "ManyToManyField"
+    elif isinstance(field, models.ManyToOneRel):
+        return "OneToManyField"
+    elif isinstance(field, models.OneToOneRel):
+        return "OneToOneField"
+    return field.__class__.__name__
+
+
 class ViewField:
     def __init__(
-            self, name, verbose_name=None, alias=None, field_type=None,
+            self, name, verbose_name=None, alias=None,
+            field_type=None, db_type=None,
             readonly=False, readonly_create=False, readonly_update=False,
-            choices=None, json_repr=None,
-            related_model=None, related_model_api=None,
+            choices=None, json_repr=None, media_field_api=None,
+            related_model=None, related_model_api=None, related_fields=None,
             select_related=None, prefetch_related=None):
         self.name = name
         self.alias = alias or name
@@ -106,10 +117,16 @@ class ViewField:
         self.readonly_update = readonly or readonly_update
         self.verbose_name = verbose_name or name
         self.field_type = field_type
+        self.db_type = db_type
         self.choices = dict(choices or [])
         self.json_repr = json_repr
+        self.media_field_api = media_field_api
         self.related_model = related_model
         self.related_model_api = related_model_api
+        self.related_fields = None
+        if self.related_model and related_fields:
+            self.related_fields = process_fields(
+                self.related_model, related_fields)
         self.select_related = select_related or []
         self.prefetch_related = prefetch_related or []
         self.model_field = None
@@ -118,7 +135,8 @@ class ViewField:
         return self.readonly_create if created else self.readonly_update
 
     def meta(self):
-        res = dict(type=self.field_type, name=self.verbose_name)
+        res = dict(
+            type=self.field_type, db_type=self.db_type, name=self.verbose_name)
         if self.choices:
             res['choices'] = [
                 dict(label=str(v), value=k) for k, v in self.choices.items()]
@@ -126,6 +144,9 @@ class ViewField:
             res['model'] = self.related_model._meta.label
             res['api'] = self.related_model_api or getattr(
                 self.related_model, 'api', None)
+            if self.related_fields:
+                res['fields'] = {
+                    n: f.meta() for n, f in self.related_fields.items()}
         res['readonly'] = dict(
             post=self.readonly_create,
             put=self.readonly_update)
@@ -144,27 +165,39 @@ class ViewField:
             return None
         return getattr(obj, name)
 
-    def _json_repr(self, value):
+    def _related_json_repr(self, value):
         if not value:
             return None
         if self.json_repr:
-            return self.json_repr(value)
-        return value.json_repr()
+            vals = self.json_repr(value)
+        else:
+            vals = value.json_repr()
+        if self.related_fields:
+            vals.update({
+                n: f.to_json(value) for n, f in self.related_fields.items()})
+        return vals
 
-    def to_json(self, view, obj):
+    def to_json(self, obj, view=None):
         value = self.get_value(obj)
 
         if self.field_type == FieldType.ModelObject:
-            return self._json_repr(value)
+            return self._related_json_repr(value)
         if self.field_type == FieldType.ModelObjectList:
-            return [self._json_repr(o) for o in value.all()]
+            return [self._related_json_repr(o) for o in value.all()]
 
         if self.json_repr:
             return self.json_repr(value)
 
         if self.field_type == FieldType.MediaField:
             if value:
-                api_url = view._rest_view_path
+                if self.media_field_api:
+                    api_url = self.media_field_api
+                elif view:
+                    api_url = view._rest_view_path
+                else:
+                    raise Exception(
+                        "media_field_api must be defined if the field "
+                        "is not a view root field.")
                 value['url'] = f'{api_url}/{obj.pk}/{self.name}'
                 return value
             else:
@@ -186,12 +219,15 @@ class ViewField:
             verbose_name = getattr(
                 prop.fget, 'short_description', prop.fget.__name__)
             field_type = getattr(prop.fget, 'field_type', None)
+            db_type = getattr(prop.fget, 'db_type', None)
         else:
             verbose_name = (
                 hasattr(prop, 'name') and prop.name or str(prop))
             field_type = None
+            db_type = None
         setifnone(kwargs, 'verbose_name', verbose_name)
         setifnone(kwargs, 'field_type', field_type)
+        setifnone(kwargs, 'db_type', db_type)
         return ViewField(name, **kwargs)
 
     @classmethod
@@ -199,6 +235,8 @@ class ViewField:
         setifnone(kwargs, 'verbose_name', cls._get_model_verbose_name(field))
         setifnone(
             kwargs, 'field_type', FieldType.from_model_field(field.__class__))
+        setifnone(
+            kwargs, 'db_type', get_db_type(field))
         return ViewModelField(
             name, model_field=field, **kwargs)
 
@@ -317,6 +355,7 @@ class ViewField:
 class ViewModelField(ViewField):
     def __init__(
             self, name, model_field=None, **kwargs):
+        related_fields = kwargs.get('related_fields')
         super().__init__(name, **kwargs)
         self.model_field = model_field
         if hasattr(model_field, 'to_json'):
@@ -324,6 +363,9 @@ class ViewModelField(ViewField):
         if (hasattr(self.model_field, 'related_model') and
                 self.model_field.related_model and not self.related_model):
             self.related_model = self.model_field.related_model
+            if self.related_model and related_fields:
+                self.related_fields = process_fields(
+                    self.related_model, related_fields)
         if not self.select_related and (
                 self.field_type == FieldType.ModelObject):
             # Auto add the field in select_related if select_related
@@ -350,7 +392,13 @@ class ViewModelField(ViewField):
 
     def to_model_value(self, value, get_related_queryset):
         def _get_obj(v):
-            pk = v['pk'] if isinstance(v, dict) and 'pk' in v else v
+            if isinstance(v, dict):
+                if 'pk' in v:
+                    pk = v['pk']
+                else:
+                    return self.model_field.related_model()
+            else:
+                pk = v
             return pk and get_object(
                 get_related_queryset(self.model_field.related_model),
                 related_field=self.name, pk=pk) or None
@@ -397,7 +445,8 @@ class VF:
             readonly=False, readonly_create=False, readonly_update=False,
             choices=None, select_related=None, prefetch_related=None,
             json_repr=None, related_model=None, related_model_api=None,
-            field=None):
+            field=None, related_fields=None, media_field_api=None,
+            db_type=None):
         self.kwargs = dict(
             name=name, verbose_name=verbose_name, field_type=field_type,
             alias=alias,
@@ -405,7 +454,27 @@ class VF:
             readonly_update=readonly_update, choices=choices,
             select_related=select_related, prefetch_related=prefetch_related,
             json_repr=json_repr, related_model=related_model,
-            related_model_api=related_model_api, field=field)
+            related_model_api=related_model_api, field=field,
+            related_fields=related_fields, media_field_api=media_field_api,
+            db_type=db_type)
 
     def to_field(self, model):
         return ViewField.from_name(model, **self.kwargs)
+
+
+def process_fields(model, fields):
+    if not fields:
+        return {
+            _f.name: ViewField.from_model_field(_f.name, _f)
+            for _f in model._meta.fields}
+
+    def _field(e):
+        if isinstance(e, ViewField):
+            field = e
+        elif isinstance(e, VF):
+            field = e.to_field(model)
+        else:
+            field = ViewField.from_name(model, e)
+        return field.alias, field
+
+    return dict(_field(e) for e in fields)

{django_pfx-1.4.dev144 → django_pfx-1.4.dev148}/pfx/pfxcore/views/rest_views.py

@@ -7,7 +7,7 @@ from django.conf import settings
 from django.core.cache import cache
 from django.core.exceptions import FieldError, ValidationError
 from django.db import IntegrityError, transaction
-from django.db.models import ForeignKey, Model, Q
+from django.db.models import ForeignKey, ManyToOneRel, Model, Q
 from django.db.models.fields import AutoFieldMixin
 from django.urls import path
 from django.utils.translation import gettext_lazy as _
@@ -36,11 +36,11 @@ from pfx.pfxcore.shortcuts import (
     get_object,
     model_permissions,
 )
+from pfx.pfxcore.views.fields import ModelList
 
 from . import parameters
-from .fields import VF
 from .fields import FieldType as FT
-from .fields import ViewField
+from .fields import process_fields
 
 logger = logging.getLogger(__name__)
 
@@ -145,21 +145,7 @@ class ModelMixin():
 
     @classmethod
     def _process_fields(cls, fields):
-        if not fields:
-            return {
-                _f.name: ViewField.from_model_field(_f.name, _f)
-                for _f in cls.model._meta.fields}
-
-        def _field(e):
-            if isinstance(e, ViewField):
-                field = e
-            elif isinstance(e, VF):
-                field = e.to_field(cls.model)
-            else:
-                field = ViewField.from_name(cls.model, e)
-            return field.alias, field
-
-        return dict(_field(e) for e in fields)
+        return process_fields(cls.model, fields)
 
     @classmethod
     def get_fields(cls):
@@ -303,7 +289,7 @@ class ModelResponseMixin(ModelMixin):
         :rtype: :class:`JsonResponse`
         """
         return JsonResponse(self.serialize_object(o, **{
-            _f.alias: _f.to_json(self, o)
+            _f.alias: _f.to_json(o, self)
             for _f in self.get_fields().values()}, meta=meta))
 
     def validate(self, obj, rel_data=None, created=False, **kwargs):
@@ -316,7 +302,34 @@ class ModelResponseMixin(ModelMixin):
         :param created: If object instance is created
         :param \\**kwargs: Additional arguments for :code:`full_clean`
         """
-        obj.full_clean(**kwargs)
+        def model_lists(rel_data):
+            if rel_data:
+                for k, v in rel_data.items():
+                    if isinstance(v, ModelList):
+                        yield k, v
+
+        errors = {}
+        for k, v in model_lists(rel_data):
+            for i, o in enumerate(v):
+                save_field = getattr(o, '_save_related', False)
+                if save_field:
+                    try:
+                        o.full_clean(exclude={save_field})
+                    except ValidationError as e:
+                        for mk, ms in e.error_dict.items():
+                            errors.setdefault(
+                                f'{k}::{i}::{mk}', []).extend(ms)
+        obj._rel_data = rel_data or {}
+        if errors:
+            try:
+                obj._rel_data = rel_data
+                obj.full_clean(**kwargs)
+            except ValidationError as e:
+                for k, ms in e.error_dict.items():
+                    errors.setdefault(k, []).extend(ms)
+            raise ValidationError(errors)
+        else:
+            obj.full_clean(**kwargs)
 
     def is_valid_response_meta(self, obj, created=False):
         """Prepare the defaut meta for is_valid responce.
@@ -356,6 +369,16 @@ class ModelResponseMixin(ModelMixin):
             obj.save()
             if rel_data:
                 for k, v in rel_data.items():
+                    if isinstance(v, ModelList):
+                        if isinstance(obj._meta.get_field(k), ManyToOneRel):
+                            for cur in getattr(obj, k).all():
+                                if cur not in v:
+                                    cur.delete()
+                        for o in v:
+                            save_field = getattr(o, '_save_related', False)
+                            if save_field:
+                                setattr(o, save_field, obj)
+                                o.save()
                     getattr(obj, k).set(v)
             self.post_save(obj, created=created, funcs=funcs)
         obj = self.get_object(pk=obj.pk)
@@ -499,7 +522,7 @@ class ModelBodyMixin(BodyMixin, ModelMixin):
         """
         fields = self.get_fields()
 
-        def can_write(fname):
+        def can_write(fname, fields):
             if fname not in fields:
                 return False
             if fields[fname].is_readonly(created=created):
@@ -512,9 +535,19 @@ class ModelBodyMixin(BodyMixin, ModelMixin):
         res = {}
         res_rel = {}
         for k, v in data.items():
-            if can_write(k):
-                mk, mv = fields[k].to_model_value(v, self.get_related_queryset)
-                if fields[k].field_type == FT.ModelObjectList:
+            if can_write(k, fields):
+                field = fields[k]
+                mk, mv = field.to_model_value(v, self.get_related_queryset)
+                if field.field_type == FT.ModelObjectList:
+                    if field.related_fields:
+                        for i, rv in enumerate(v):
+                            for rk, rf in field.related_fields.items():
+                                rmk, rmv = rf.to_model_value(
+                                    rv.get(rk), self.get_related_queryset)
+                                setattr(mv[i], rmk, rmv)
+                            setattr(
+                                mv[i], '_save_related',
+                                field.model_field.field.name)
                     res_rel[mk] = mv
                 else:
                     res[mk] = mv
@@ -768,7 +801,7 @@ class ListRestViewMixin(ModelResponseMixin):
             *self.get_list_fields_prefetch_related())
         for o in qs:
             yield self.serialize_object(o, **{
-                _f.alias: _f.to_json(self, o)
+                _f.alias: _f.to_json(o, self)
                 for _f in self.get_list_fields().values()})
 
     def get_short_list_result(self, qs):

{django_pfx-1.4.dev144 → django_pfx-1.4.dev148}/tests/tests/__init__.py

@@ -11,6 +11,7 @@ from .test_fields_date import TestFieldsDate
 from .test_fields_decimal import TestFieldsDecimal
 from .test_fields_minutes_duration import TestFieldsMinutesDuration
 from .test_fields_nh3 import TestFieldsNh3
+from .test_fields_one2many import TestFieldsOne2Many
 from .test_filters import FiltersTest
 from .test_locale_api import LocaleAPITest
 from .test_ordered_rest_view_mixin import TestOrderedRestViewMixin

django_pfx-1.4.dev148/tests/tests/test_fields_one2many.py

@@ -0,0 +1,197 @@
+from django.core.exceptions import NON_FIELD_ERRORS, ValidationError
+from django.db import connection, models
+from django.test import TestCase
+from django.test.utils import override_settings
+from django.urls import include, path
+
+from pfx.pfxcore import register_views
+from pfx.pfxcore.decorator import rest_view
+from pfx.pfxcore.models import JSONReprMixin
+from pfx.pfxcore.test import APIClient, TestAssertMixin
+from pfx.pfxcore.views import VF, RestView
+from tests.views import FakeViewMixin
+
+
+class TestOne2ManyModel(JSONReprMixin, models.Model):
+    name = models.CharField(max_length=30)
+
+    class Meta:
+        verbose_name = "TestOne2ManyModel"
+        verbose_name_plural = "TestOne2ManyModel"
+        ordering = ['pk']
+
+    def clean_fields(self, exclude=None):
+        errors = {}
+
+        if 'rels' not in exclude and 'rels' in self._rel_data:
+            if len(self._rel_data['rels']) < 2:
+                errors.setdefault(NON_FIELD_ERRORS, []).append(
+                    "You have to set minimum 2 rels.")
+
+        try:
+            super().clean_fields(exclude)
+        except ValidationError as e:
+            for k, ms in e.error_dict.items():
+                errors.setdefault(k, []).extend(ms)
+
+        if errors:
+            raise ValidationError(errors)
+
+
+class TestOne2ManyRelModel(JSONReprMixin, models.Model):
+    name = models.CharField(max_length=30)
+    descr = models.TextField()
+    rel = models.ForeignKey(
+        TestOne2ManyModel, related_name='rels', on_delete=models.CASCADE)
+
+    class Meta:
+        verbose_name = "TestOne2ManyRelModel"
+        verbose_name_plural = "TestOne2ManyRelModels"
+        ordering = ['pk']
+
+
+@rest_view("/test")
+class TestOne2ManyRestView(FakeViewMixin, RestView):
+    default_public = True
+    model = TestOne2ManyModel
+
+    fields = ['name', VF('rels', related_fields=[
+        'name', VF('descr', readonly=True)])]
+
+
+urlpatterns = [
+    path('api/', include(register_views(TestOne2ManyRestView))),
+    path('api/', include('pfx.pfxcore.urls'))
+]
+
+
+@override_settings(ROOT_URLCONF=__name__)
+class TestFieldsOne2Many(TestAssertMixin, TestCase):
+
+    def setUp(self):
+        self.client = APIClient(default_locale='en')
+
+    @classmethod
+    def setUpTestData(cls):
+        with connection.schema_editor() as schema_editor:
+            schema_editor.create_model(TestOne2ManyModel)
+            schema_editor.create_model(TestOne2ManyRelModel)
+
+    def test_meta(self):
+        response = self.client.get('/api/test/meta')
+        self.assertRC(response, 200)
+        fields = 'fields.rels.fields'
+        self.assertJE(response, f'{fields}.name.name', "name")
+        self.assertJE(response, f'{fields}.name.type', "CharField")
+        self.assertJE(response, f'{fields}.name.required', True)
+        self.assertJE(response, f'{fields}.name.readonly.post', False)
+        self.assertJE(response, f'{fields}.name.readonly.put', False)
+        self.assertJE(response, f'{fields}.descr.name', "descr")
+        self.assertJE(response, f'{fields}.descr.type', "TextField")
+        self.assertJE(response, f'{fields}.descr.required', True)
+        self.assertJE(response, f'{fields}.descr.readonly.post', True)
+        self.assertJE(response, f'{fields}.descr.readonly.put', True)
+
+    def test_get(self):
+        o = TestOne2ManyModel.objects.create(name="Test")
+        r1 = TestOne2ManyRelModel.objects.create(rel=o, name="R1", descr="D1")
+        r2 = TestOne2ManyRelModel.objects.create(rel=o, name="R2", descr="D2")
+
+        response = self.client.get(f'/api/test/{o.pk}')
+        self.assertRC(response, 200)
+        self.assertSize(response, 'rels', 2)
+        self.assertJE(response, 'rels.@0.pk', r1.pk)
+        self.assertJE(response, 'rels.@0.name', "R1")
+        self.assertJE(response, 'rels.@0.descr', "D1")
+        self.assertJE(response, 'rels.@1.pk', r2.pk)
+        self.assertJE(response, 'rels.@1.name', "R2")
+        self.assertJE(response, 'rels.@1.descr', "D2")
+
+    def test_post(self):
+        response = self.client.post('/api/test', dict(
+            name="Test",
+            rels=[dict(name="R1", descr="D1"), dict(name="R2", descr="D2")]
+        ))
+        self.assertRC(response, 200)
+        self.assertSize(response, 'rels', 2)
+        self.assertJE(response, 'rels.@0.name', "R1")
+        self.assertJE(response, 'rels.@0.descr', "D1")
+        self.assertJE(response, 'rels.@1.name', "R2")
+        self.assertJE(response, 'rels.@1.descr', "D2")
+
+    def test_post_field_errors(self):
+        response = self.client.post('/api/test', dict(
+            rels=[dict(name="R1", descr="D1"), dict(descr="D2")]
+        ))
+        self.assertRC(response, 422)
+        self.assertEqual(
+            set(response.json().keys()), {'name', 'rels::1::name'})
+        self.assertJE(response, 'name', ["This field cannot be blank."])
+        self.assertJE(
+            response, 'rels::1::name', ["This field cannot be null."])
+
+        response = self.client.post('/api/test', dict(
+            rels=[dict(descr="D1")]
+        ))
+        self.assertRC(response, 422)
+        self.assertEqual(
+            set(response.json().keys()), {'__all__', 'name', 'rels::0::name'})
+        self.assertJE(response, '__all__', ["You have to set minimum 2 rels."])
+        self.assertJE(response, 'name', ["This field cannot be blank."])
+        self.assertJE(
+            response, 'rels::0::name', ["This field cannot be null."])
+
+    def test_put(self):
+        o = TestOne2ManyModel.objects.create(name="Test")
+        r1 = TestOne2ManyRelModel.objects.create(rel=o, name="R1", descr="D1")
+
+        vals = self.client.get(f'/api/test/{o.pk}').json()
+        vals['rels'][0]['name'] = "R1 updated"
+        vals['rels'].append({'name': "R2", "descr": "D2"})
+
+        response = self.client.put(f'/api/test/{o.pk}', vals)
+        self.assertRC(response, 200)
+        self.assertSize(response, 'rels', 2)
+        self.assertJE(response, 'rels.@0.pk', r1.pk)
+        self.assertJE(response, 'rels.@0.name', "R1 updated")
+        self.assertJE(response, 'rels.@0.descr', "D1")
+        self.assertJE(response, 'rels.@1.name', "R2")
+        self.assertJE(response, 'rels.@1.descr', "D2")
+
+    def test_put_field_errors(self):
+        o = TestOne2ManyModel.objects.create(name="Test")
+        TestOne2ManyRelModel.objects.create(rel=o, name="R1", descr="D1")
+        TestOne2ManyRelModel.objects.create(rel=o, name="R2", descr="D2")
+
+        vals = self.client.get(f'/api/test/{o.pk}').json()
+        vals['name'] = ""
+        vals['rels'][0]['name'] = None
+        del vals['rels'][1]
+
+        response = self.client.put(f'/api/test/{o.pk}', vals)
+        self.assertRC(response, 422)
+        self.assertEqual(
+            set(response.json().keys()), {'__all__', 'name', 'rels::0::name'})
+        self.assertJE(response, '__all__', ["You have to set minimum 2 rels."])
+        self.assertJE(response, 'name', ["This field cannot be blank."])
+        self.assertJE(
+            response, 'rels::0::name', ["This field cannot be null."])
+
+    def test_put_delete(self):
+        o = TestOne2ManyModel.objects.create(name="Test")
+        r1 = TestOne2ManyRelModel.objects.create(rel=o, name="R1", descr="D1")
+        r2 = TestOne2ManyRelModel.objects.create(rel=o, name="R2", descr="D2")
+        TestOne2ManyRelModel.objects.create(rel=o, name="R3", descr="D3")
+
+        vals = self.client.get(f'/api/test/{o.pk}').json()
+        del vals['rels'][2]
+
+        response = self.client.put(f'/api/test/{o.pk}', vals)
+        self.assertRC(response, 200)
+        self.assertSize(response, 'rels', 2)
+        self.assertJE(response, 'rels.@0.pk', r1.pk)
+        self.assertJE(response, 'rels.@0.name', "R1")
+        self.assertJE(response, 'rels.@0.descr', "D1")
+        self.assertJE(response, 'rels.@1.pk', r2.pk)
+        self.assertJE(response, 'rels.@1.name', "R2")
+        self.assertJE(response, 'rels.@1.descr', "D2")