From b6af206e35446af9f205c3f7767ce423c8803f2f Mon Sep 17 00:00:00 2001 From: Vincent Lefoulon Date: Sun, 13 Aug 2017 16:32:45 -0400 Subject: [PATCH 1/2] Add tests for unique_with constraint --- tests/test_reference.py | 108 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 108 insertions(+) diff --git a/tests/test_reference.py b/tests/test_reference.py index 7e593e9..45c0e5f 100644 --- a/tests/test_reference.py +++ b/tests/test_reference.py @@ -59,6 +59,11 @@ class ReferencingDocWithUniqueField(Document): ref = fields.ReferenceField(ReferencedDocWithUniqueField, unique=True) +class ReferencingDocWithUniqueWithField(Document): + ref1 = fields.ReferenceField(ReferencedDoc, unique_with='ref2') + ref2 = fields.ReferenceField(OtherReferencedDoc) + + class GenericReferencingDoc(Document): ref = fields.GenericReferenceField() @@ -611,6 +616,109 @@ class Meta: assert serializer.data == expected +class TestUniqueWithReferenceIntegration(TestCase): + def setUp(self): + self.target1 = ReferencedDoc.objects.create( + name='Foo' + ) + self.target2 = OtherReferencedDoc.objects.create( + name='Bar' + ) + self.target2_ = OtherReferencedDoc.objects.create( + name='Bar2' + ) + + def doCleanups(self): + ReferencedDocWithUniqueField.drop_collection() + ReferencingDocWithUniqueWithField.drop_collection() + + def test_retrieval(self): + instance = ReferencingDocWithUniqueWithField.objects.create( + ref1=self.target1, + ref2=self.target2 + ) + + class TestSerializer(DocumentSerializer): + class Meta: + model = ReferencingDocWithUniqueWithField + fields = '__all__' + depth = 0 + + serializer = TestSerializer(instance) + expected = { + 'id': str(instance.id), + 'ref1': str(self.target1.id), + 'ref2': str(self.target2.id), + } + assert serializer.data == expected + + def test_create(self): + instance = ReferencingDocWithUniqueWithField.objects.create( + ref1=self.target1, + ref2=self.target2 + ) + + class TestSerializer(DocumentSerializer): + class Meta: + model = ReferencingDocWithUniqueWithField + fields = '__all__' + depth = 0 + + data = {'ref1': str(self.target1.id), 'ref2': str(self.target2.id)} + serializer = TestSerializer(data=data) + + assert not serializer.is_valid(), not serializer.errors + + data = {'ref1': str(self.target1.id), 'ref2': str(self.target2_.id)} + serializer = TestSerializer(data=data) + + assert serializer.is_valid(), serializer.errors + + expected = { + 'id': str(instance.id), + 'ref1': str(self.target1.id), + 'ref2': str(self.target2_.id), + } + assert serializer.data == expected + + + def test_update(self): + instance1 = ReferencingDocWithUniqueWithField.objects.create( + ref1=self.target1, + ref2=self.target2 + ) + instance2 = ReferencingDocWithUniqueWithField.objects.create( + ref1=self.target1, + ref2=self.target2_ + ) + + class TestSerializer(DocumentSerializer): + class Meta: + model = ReferencingDocWithUniqueWithField + fields = '__all__' + depth = 0 + + data = {'ref1': str(instance1.ref1.id)} + serializer = TestSerializer(instance1, data=data) + assert serializer.is_valid(), serializer.errors + + expected = { + 'id': str(instance1.id), + 'ref1': str(self.target1.id), + 'ref2': str(self.target2.id), + } + assert serializer.data == expected + + obj = serializer.save() + assert obj.id == instance1.id + assert obj.ref1 == instance1.ref1 + assert obj.ref2 == instance1.ref2 + + data = {'ref2': str(instance2.ref2.id)} + serializer = TestSerializer(instance1, data=data) + assert not serializer.is_valid(), not serializer.errors + + class TestGenericReferenceIntegration(TestCase): def setUp(self): self.target = ReferencedDoc.objects.create(name='Foo') From b85fc3f6957315bd4532dfd85b7158986305eb75 Mon Sep 17 00:00:00 2001 From: Vincent Lefoulon Date: Tue, 26 Sep 2017 11:03:28 +0200 Subject: [PATCH 2/2] Define index in the meta attribute unique_with makes mongoengine crash. --- tests/test_reference.py | 24 ++++++++++++------------ 1 file changed, 12 insertions(+), 12 deletions(-) diff --git a/tests/test_reference.py b/tests/test_reference.py index 45c0e5f..b566ada 100644 --- a/tests/test_reference.py +++ b/tests/test_reference.py @@ -60,9 +60,18 @@ class ReferencingDocWithUniqueField(Document): class ReferencingDocWithUniqueWithField(Document): - ref1 = fields.ReferenceField(ReferencedDoc, unique_with='ref2') + ref1 = fields.ReferenceField(ReferencedDoc) ref2 = fields.ReferenceField(OtherReferencedDoc) + meta = { + 'indexes': [ + { + 'fields': ['ref1', 'ref2'], + 'unique': True + } + ] + } + class GenericReferencingDoc(Document): ref = fields.GenericReferenceField() @@ -666,7 +675,6 @@ class Meta: data = {'ref1': str(self.target1.id), 'ref2': str(self.target2.id)} serializer = TestSerializer(data=data) - assert not serializer.is_valid(), not serializer.errors data = {'ref1': str(self.target1.id), 'ref2': str(self.target2_.id)} @@ -675,7 +683,6 @@ class Meta: assert serializer.is_valid(), serializer.errors expected = { - 'id': str(instance.id), 'ref1': str(self.target1.id), 'ref2': str(self.target2_.id), } @@ -699,23 +706,16 @@ class Meta: depth = 0 data = {'ref1': str(instance1.ref1.id)} - serializer = TestSerializer(instance1, data=data) + serializer = TestSerializer(instance1, data=data, partial=True,) assert serializer.is_valid(), serializer.errors - expected = { - 'id': str(instance1.id), - 'ref1': str(self.target1.id), - 'ref2': str(self.target2.id), - } - assert serializer.data == expected - obj = serializer.save() assert obj.id == instance1.id assert obj.ref1 == instance1.ref1 assert obj.ref2 == instance1.ref2 data = {'ref2': str(instance2.ref2.id)} - serializer = TestSerializer(instance1, data=data) + serializer = TestSerializer(instance1, data=data, partial=True,) assert not serializer.is_valid(), not serializer.errors