BVB Source Codes

django-rest-framework Show test_metadata.py Source code

Return Download django-rest-framework: download test_metadata.py Source code - Download django-rest-framework Source code - Type:.py
  1. from __future__ import unicode_literals
  2.  
  3. import pytest
  4. from django.core.validators import MaxValueValidator, MinValueValidator
  5. from django.db import models
  6. from django.test import TestCase
  7.  
  8. from rest_framework import (
  9.     exceptions, metadata, serializers, status, versioning, views
  10. )
  11. from rest_framework.renderers import BrowsableAPIRenderer
  12. from rest_framework.request import Request
  13. from rest_framework.test import APIRequestFactory
  14.  
  15. from .models import BasicModel
  16.  
  17. request = Request(APIRequestFactory().options('/'))
  18.  
  19.  
  20. class TestMetadata:
  21.  
  22.     def test_determine_metadata_abstract_method_raises_proper_error(self):
  23.         with pytest.raises(NotImplementedError):
  24.             metadata.BaseMetadata().determine_metadata(None, None)
  25.  
  26.     def test_metadata(self):
  27.         """
  28.        OPTIONS requests to views should return a valid 200 response.
  29.        """
  30.         class ExampleView(views.APIView):
  31.             """Example view."""
  32.             pass
  33.  
  34.         view = ExampleView.as_view()
  35.         response = view(request=request)
  36.         expected = {
  37.             'name': 'Example',
  38.             'description': 'Example view.',
  39.             'renders': [
  40.                 'application/json',
  41.                 'text/html'
  42.             ],
  43.             'parses': [
  44.                 'application/json',
  45.                 'application/x-www-form-urlencoded',
  46.                 'multipart/form-data'
  47.             ]
  48.         }
  49.         assert response.status_code == status.HTTP_200_OK
  50.         assert response.data == expected
  51.  
  52.     def test_none_metadata(self):
  53.         """
  54.        OPTIONS requests to views where `metadata_class = None` should raise
  55.        a MethodNotAllowed exception, which will result in an HTTP 405 response.
  56.        """
  57.         class ExampleView(views.APIView):
  58.             metadata_class = None
  59.  
  60.         view = ExampleView.as_view()
  61.         response = view(request=request)
  62.         assert response.status_code == status.HTTP_405_METHOD_NOT_ALLOWED
  63.         assert response.data == {'detail': 'Method "OPTIONS" not allowed.'}
  64.  
  65.     def test_actions(self):
  66.         """
  67.        On generic views OPTIONS should return an 'actions' key with metadata
  68.        on the fields that may be supplied to PUT and POST requests.
  69.        """
  70.         class NestedField(serializers.Serializer):
  71.             a = serializers.IntegerField()
  72.             b = serializers.IntegerField()
  73.  
  74.         class ExampleSerializer(serializers.Serializer):
  75.             choice_field = serializers.ChoiceField(['red', 'green', 'blue'])
  76.             integer_field = serializers.IntegerField(
  77.                 min_value=1, max_value=1000
  78.             )
  79.             char_field = serializers.CharField(
  80.                 required=False, min_length=3, max_length=40
  81.             )
  82.             list_field = serializers.ListField(
  83.                 child=serializers.ListField(
  84.                     child=serializers.IntegerField()
  85.                 )
  86.             )
  87.             nested_field = NestedField()
  88.  
  89.         class ExampleView(views.APIView):
  90.             """Example view."""
  91.             def post(self, request):
  92.                 pass
  93.  
  94.             def get_serializer(self):
  95.                 return ExampleSerializer()
  96.  
  97.         view = ExampleView.as_view()
  98.         response = view(request=request)
  99.         expected = {
  100.             'name': 'Example',
  101.             'description': 'Example view.',
  102.             'renders': [
  103.                 'application/json',
  104.                 'text/html'
  105.             ],
  106.             'parses': [
  107.                 'application/json',
  108.                 'application/x-www-form-urlencoded',
  109.                 'multipart/form-data'
  110.             ],
  111.             'actions': {
  112.                 'POST': {
  113.                     'choice_field': {
  114.                         'type': 'choice',
  115.                         'required': True,
  116.                         'read_only': False,
  117.                         'label': 'Choice field',
  118.                         'choices': [
  119.                             {'display_name': 'red', 'value': 'red'},
  120.                             {'display_name': 'green', 'value': 'green'},
  121.                             {'display_name': 'blue', 'value': 'blue'}
  122.                         ]
  123.                     },
  124.                     'integer_field': {
  125.                         'type': 'integer',
  126.                         'required': True,
  127.                         'read_only': False,
  128.                         'label': 'Integer field',
  129.                         'min_value': 1,
  130.                         'max_value': 1000,
  131.  
  132.                     },
  133.                     'char_field': {
  134.                         'type': 'string',
  135.                         'required': False,
  136.                         'read_only': False,
  137.                         'label': 'Char field',
  138.                         'min_length': 3,
  139.                         'max_length': 40
  140.                     },
  141.                     'list_field': {
  142.                         'type': 'list',
  143.                         'required': True,
  144.                         'read_only': False,
  145.                         'label': 'List field',
  146.                         'child': {
  147.                             'type': 'list',
  148.                             'required': True,
  149.                             'read_only': False,
  150.                             'child': {
  151.                                 'type': 'integer',
  152.                                 'required': True,
  153.                                 'read_only': False
  154.                             }
  155.                         }
  156.                     },
  157.                     'nested_field': {
  158.                         'type': 'nested object',
  159.                         'required': True,
  160.                         'read_only': False,
  161.                         'label': 'Nested field',
  162.                         'children': {
  163.                             'a': {
  164.                                 'type': 'integer',
  165.                                 'required': True,
  166.                                 'read_only': False,
  167.                                 'label': 'A'
  168.                             },
  169.                             'b': {
  170.                                 'type': 'integer',
  171.                                 'required': True,
  172.                                 'read_only': False,
  173.                                 'label': 'B'
  174.                             }
  175.                         }
  176.                     }
  177.                 }
  178.             }
  179.         }
  180.         assert response.status_code == status.HTTP_200_OK
  181.         assert response.data == expected
  182.  
  183.     def test_global_permissions(self):
  184.         """
  185.        If a user does not have global permissions on an action, then any
  186.        metadata associated with it should not be included in OPTION responses.
  187.        """
  188.         class ExampleSerializer(serializers.Serializer):
  189.             choice_field = serializers.ChoiceField(['red', 'green', 'blue'])
  190.             integer_field = serializers.IntegerField(max_value=10)
  191.             char_field = serializers.CharField(required=False)
  192.  
  193.         class ExampleView(views.APIView):
  194.             """Example view."""
  195.             def post(self, request):
  196.                 pass
  197.  
  198.             def put(self, request):
  199.                 pass
  200.  
  201.             def get_serializer(self):
  202.                 return ExampleSerializer()
  203.  
  204.             def check_permissions(self, request):
  205.                 if request.method == 'POST':
  206.                     raise exceptions.PermissionDenied()
  207.  
  208.         view = ExampleView.as_view()
  209.         response = view(request=request)
  210.         assert response.status_code == status.HTTP_200_OK
  211.         assert list(response.data['actions'].keys()) == ['PUT']
  212.  
  213.     def test_object_permissions(self):
  214.         """
  215.        If a user does not have object permissions on an action, then any
  216.        metadata associated with it should not be included in OPTION responses.
  217.        """
  218.         class ExampleSerializer(serializers.Serializer):
  219.             choice_field = serializers.ChoiceField(['red', 'green', 'blue'])
  220.             integer_field = serializers.IntegerField(max_value=10)
  221.             char_field = serializers.CharField(required=False)
  222.  
  223.         class ExampleView(views.APIView):
  224.             """Example view."""
  225.             def post(self, request):
  226.                 pass
  227.  
  228.             def put(self, request):
  229.                 pass
  230.  
  231.             def get_serializer(self):
  232.                 return ExampleSerializer()
  233.  
  234.             def get_object(self):
  235.                 if self.request.method == 'PUT':
  236.                     raise exceptions.PermissionDenied()
  237.  
  238.         view = ExampleView.as_view()
  239.         response = view(request=request)
  240.         assert response.status_code == status.HTTP_200_OK
  241.         assert list(response.data['actions'].keys()) == ['POST']
  242.  
  243.     def test_bug_2455_clone_request(self):
  244.         class ExampleView(views.APIView):
  245.             renderer_classes = (BrowsableAPIRenderer,)
  246.  
  247.             def post(self, request):
  248.                 pass
  249.  
  250.             def get_serializer(self):
  251.                 assert hasattr(self.request, 'version')
  252.                 return serializers.Serializer()
  253.  
  254.         view = ExampleView.as_view()
  255.         view(request=request)
  256.  
  257.     def test_bug_2477_clone_request(self):
  258.         class ExampleView(views.APIView):
  259.             renderer_classes = (BrowsableAPIRenderer,)
  260.  
  261.             def post(self, request):
  262.                 pass
  263.  
  264.             def get_serializer(self):
  265.                 assert hasattr(self.request, 'versioning_scheme')
  266.                 return serializers.Serializer()
  267.  
  268.         scheme = versioning.QueryParameterVersioning
  269.         view = ExampleView.as_view(versioning_class=scheme)
  270.         view(request=request)
  271.  
  272.     def test_list_serializer_metadata_returns_info_about_fields_of_child_serializer(self):
  273.         class ExampleSerializer(serializers.Serializer):
  274.             integer_field = serializers.IntegerField(max_value=10)
  275.             char_field = serializers.CharField(required=False)
  276.  
  277.         class ExampleListSerializer(serializers.ListSerializer):
  278.             pass
  279.  
  280.         options = metadata.SimpleMetadata()
  281.         child_serializer = ExampleSerializer()
  282.         list_serializer = ExampleListSerializer(child=child_serializer)
  283.         assert options.get_serializer_info(list_serializer) == options.get_serializer_info(child_serializer)
  284.  
  285.  
  286. class TestSimpleMetadataFieldInfo(TestCase):
  287.     def test_null_boolean_field_info_type(self):
  288.         options = metadata.SimpleMetadata()
  289.         field_info = options.get_field_info(serializers.NullBooleanField())
  290.         assert field_info['type'] == 'boolean'
  291.  
  292.     def test_related_field_choices(self):
  293.         options = metadata.SimpleMetadata()
  294.         BasicModel.objects.create()
  295.         with self.assertNumQueries(0):
  296.             field_info = options.get_field_info(
  297.                 serializers.RelatedField(queryset=BasicModel.objects.all())
  298.             )
  299.         assert 'choices' not in field_info
  300.  
  301.  
  302. class TestModelSerializerMetadata(TestCase):
  303.     def test_read_only_primary_key_related_field(self):
  304.         """
  305.        On generic views OPTIONS should return an 'actions' key with metadata
  306.        on the fields that may be supplied to PUT and POST requests. It should
  307.        not fail when a read_only PrimaryKeyRelatedField is present
  308.        """
  309.         class Parent(models.Model):
  310.             integer_field = models.IntegerField(validators=[MinValueValidator(1), MaxValueValidator(1000)])
  311.             children = models.ManyToManyField('Child')
  312.             name = models.CharField(max_length=100, blank=True, null=True)
  313.  
  314.         class Child(models.Model):
  315.             name = models.CharField(max_length=100)
  316.  
  317.         class ExampleSerializer(serializers.ModelSerializer):
  318.             children = serializers.PrimaryKeyRelatedField(read_only=True, many=True)
  319.  
  320.             class Meta:
  321.                 model = Parent
  322.                 fields = '__all__'
  323.  
  324.         class ExampleView(views.APIView):
  325.             """Example view."""
  326.             def post(self, request):
  327.                 pass
  328.  
  329.             def get_serializer(self):
  330.                 return ExampleSerializer()
  331.  
  332.         view = ExampleView.as_view()
  333.         response = view(request=request)
  334.         expected = {
  335.             'name': 'Example',
  336.             'description': 'Example view.',
  337.             'renders': [
  338.                 'application/json',
  339.                 'text/html'
  340.             ],
  341.             'parses': [
  342.                 'application/json',
  343.                 'application/x-www-form-urlencoded',
  344.                 'multipart/form-data'
  345.             ],
  346.             'actions': {
  347.                 'POST': {
  348.                     'id': {
  349.                         'type': 'integer',
  350.                         'required': False,
  351.                         'read_only': True,
  352.                         'label': 'ID'
  353.                     },
  354.                     'children': {
  355.                         'type': 'field',
  356.                         'required': False,
  357.                         'read_only': True,
  358.                         'label': 'Children'
  359.                     },
  360.                     'integer_field': {
  361.                         'type': 'integer',
  362.                         'required': True,
  363.                         'read_only': False,
  364.                         'label': 'Integer field',
  365.                         'min_value': 1,
  366.                         'max_value': 1000
  367.                     },
  368.                     'name': {
  369.                         'type': 'string',
  370.                         'required': False,
  371.                         'read_only': False,
  372.                         'label': 'Name',
  373.                         'max_length': 100
  374.                     }
  375.                 }
  376.             }
  377.         }
  378.  
  379.         assert response.status_code == status.HTTP_200_OK
  380.         assert response.data == expected
  381.  
downloadtest_metadata.py Source code - Download django-rest-framework Source code
Related Source Codes/Software:
lectures - Oxford Deep NLP 2017 course 2017-06-10
algorithms - Minimal examples of data structures and algorithms... 2017-06-10
Awesome-Hacking - A collection of various awesome lists for hackers,... 2017-06-09
lottie-ios - An iOS library to natively render After Effects ve... 2017-06-09
Public-APIs - 2017-06-09
angular-starter - 2017-06-10
redux-saga - An alternative side effect model for Redux apps ... 2017-06-10
pyenv - Simple Python version management 2017-06-10
goreplay - GoReplay is an open-source tool for capturing and ... 2017-06-10
realworld - TodoMVC for the RealWorld - Exemplary fullstack Me... 2017-06-11
CRYENGINE - CRYENGINE is a powerful real-time game development... 2017-06-11
postal - 2017-06-11
reactide - Reactide is the first dedicated IDE for React web ... 2017-06-11
rkt - rkt is a pod-native container engine for Linux. It... 2017-06-11
uWebSockets - Tiny WebSockets https://for... 2017-06-11

 Back to top