def define_relationships():
return {
"authors": RelationshipHandler(AuthorSerializer,
"authors",
many=True),
"publisher": RelationshipHandler(PublisherSerializer, "publisher"),
}
def test_apply_pagination(self):
related = list(range(20))
handler = RelationshipHandler(TestModelSerializer,
related_field="related_things",
many=True)
data, meta = handler.apply_pagination(related,
page_size=10,
page_number=1)
self.assertEqual(len(data), 10)
self.assertEqual(meta["count"], 20)
self.assertTrue(meta["has_next"])
def test_build_relationship_links(self, mock_reverse):
resource = TestModel.objects.create()
request = RequestFactory().get("/test_resources/1")
TestModelSerializer.get_id = mock.MagicMock(return_value=1)
handler = RelationshipHandler(TestModelSerializer,
related_field="related_things",
many=True)
links = handler.build_relationship_links(TestModelSerializer,
"related_things", resource,
request)
self.assertDictEqual(
links,
{
"self":
f"http://testserver/test_resources/{mock_reverse.return_value}"
},
)
def test_lookup_serializer_by_string_cannot_be_resolved(self):
with self.assertRaises(ImportError):
RelationshipHandler("fake.not_here.Serializer")
def test_lookup_serializer_by_string(self, mock_serializer):
handler = RelationshipHandler("tests.mocks.TestResourceSerializer")
self.assertEqual(
handler.serializer_class,
mock_serializer.return_value.TestResourceSerializer,
)
def test_to_one_relationship(self):
handler = RelationshipHandler(TestModelSerializer,
related_field="related_things",
many=False)
self.assertEqual(handler.related_field, "related_things")
self.assertEqual(handler.many, False)
def setUp(self):
self.relationship_handler = RelationshipHandler(NodeSerializer)
self.node_parent_handler = NodeParentHandler(NodeSerializer)
self.node_children_handler = NodeChildrenHandler(NodeSerializer)
self.node_links_to_handler = NodeLinksToHandler(NodeSerializer)
def define_relationships():
return {
"books": RelationshipHandler(BookSerializer, "books", many=True)
}
class RelationshipHandlerTestCase(TestCase):
def setUp(self):
self.relationship_handler = RelationshipHandler(NodeSerializer)
self.node_parent_handler = NodeParentHandler(NodeSerializer)
self.node_children_handler = NodeChildrenHandler(NodeSerializer)
self.node_links_to_handler = NodeLinksToHandler(NodeSerializer)
def test_get_links(self):
links = {"foo": "bar"}
self.assertEqual(
self.relationship_handler.get_links(None, links, None), links)
def test_get_related_not_implemented(self):
with self.assertRaises(NotImplementedError):
self.relationship_handler.get_related(None, None)
def test_get_related_one(self):
a = Node.objects.create(name="a")
b = Node.objects.create(name="b", parent=a)
related = self.node_parent_handler.get_related(b, None)
self.assertEqual(related.id, a.id)
def test_get_related_many(self):
a = Node.objects.create(name="a")
Node.objects.create(name="b", parent=a)
related = self.node_children_handler.get_related(a, None)
self.assertEqual(len(related), 1)
def test_add_related_not_implemented(self):
self.relationship_handler.many = True
with self.assertRaises(NotImplementedError):
self.relationship_handler.add_related(None, None, None)
def test_add_related_iterable(self):
a = Node.objects.create(name="a")
b = Node.objects.create(name="b")
self.node_links_to_handler.add_related(a, [b], None)
self.assertEqual(a.links_to.all().count(), 1)
def test_add_related_scalar(self):
a = Node.objects.create(name="a")
b = Node.objects.create(name="b")
self.node_links_to_handler.add_related(a, b, None)
self.assertEqual(a.links_to.all().count(), 1)
def test_set_related_not_implemented(self):
with self.assertRaises(NotImplementedError):
self.relationship_handler.set_related(None, None, None)
def test_set_related_one(self):
a = Node.objects.create(name="a")
b = Node.objects.create(name="b")
self.node_parent_handler.set_related(b, a, None)
self.assertEqual(b.parent.id, a.id)
def test_set_related_many(self):
a = Node.objects.create(name="a")
b = Node.objects.create(name="b")
self.node_links_to_handler.set_related(b, [a], None)
self.assertEqual(b.links_to.all().count(), 1)
def test_remove_related_not_implemented(self):
self.relationship_handler.many = True
with self.assertRaises(NotImplementedError):
self.relationship_handler.remove_related(None, None, None)
def test_set_related_many_scalar(self):
a = Node.objects.create(name="a")
b = Node.objects.create(name="b")
a.links_to.add(b)
self.node_links_to_handler.remove_related(a, b, None)
self.assertEqual(a.links_to.all().count(), 0)
def test_set_related_many_iterable(self):
a = Node.objects.create(name="a")
b = Node.objects.create(name="b")
a.links_to.add(b)
self.node_links_to_handler.remove_related(a, [b], None)
self.assertEqual(a.links_to.all().count(), 0)
def test_remove_related_not_implemented(self):
handler = RelationshipHandler()
handler.many = True
with self.assertRaises(NotImplementedError):
handler.remove_related(None, None)
def test_set_related_not_implemented(self):
with self.assertRaises(NotImplementedError):
RelationshipHandler().set_related(None, None)
def test_get_links(self):
links = {"foo": "bar"}
self.assertEqual(RelationshipHandler().get_links(None, links), links)
def test_get_serializer_class_not_implemented(self):
with self.assertRaises(NotImplementedError):
RelationshipHandler().get_serializer_class()