text: from __future__ import unicode_literals
  
  from django.test import TestCase, override_settings
  
  from django_countries import countries
  from django_countries.fields import Country
  from django_countries.tests.models import Person, MultiCountry
  from django_countries.tests.custom_countries import FantasyCountries
  from django_countries.serializers import CountryFieldMixin
  
  from rest_framework.test import APIRequestFactory
  from rest_framework import serializers, views
  
  
  def countries_display(countries):
      """
      Convert Countries into a DRF-OPTIONS formatted dict.
      """
      return [{'display_name': v, 'value': k} for (k, v) in countries]
  
  
  class PersonSerializer(CountryFieldMixin, serializers.ModelSerializer):
  
      class Meta:
          model = Person
          fields = (
              'name', 'country', 'other_country', 'favourite_country',
              'fantasy_country')
          extra_kwargs = {
              'other_country': {'country_dict': True},
          }
  
  
  class MultiCountrySerializer(CountryFieldMixin, serializers.ModelSerializer):
  
      class Meta:
          model = MultiCountry
          fields = ('countries',)
  
  
  class TestDRF(TestCase):
  
      def test_serialize(self):
          person = Person(name='Chris Beaven', country='NZ')
          serializer = PersonSerializer(person)
          self.assertEqual(
              serializer.data,
              {
                  'name': 'Chris Beaven',
                  'country': 'NZ',
                  'other_country': '',
                  'favourite_country': 'NZ',
                  'fantasy_country': '',
              })
  
      def test_serialize_country_dict(self):
          person = Person(name='Chris Beaven', other_country='AU')
          serializer = PersonSerializer(person)
          self.assertEqual(
              serializer.data,
              {
                  'name': 'Chris Beaven',
                  'country': '',
                  'other_country': {'code': 'AU', 'name': 'Australia'},
                  'favourite_country': 'NZ',
                  'fantasy_country': '',
              })
  
      def test_deserialize(self):
          serializer = PersonSerializer(data={
              'name': 'Tester',
              'country': 'US',
              'fantasy_country': 'NV',
          })
          self.assertTrue(serializer.is_valid())
          self.assertEqual(serializer.validated_data['country'], 'US')
  
      def test_deserialize_country_dict(self):
          serializer = PersonSerializer(data={
              'name': 'Tester',
              'country': {'code': 'GB', 'name': 'Anything'},
              'fantasy_country': 'NV'
          })
          self.assertTrue(serializer.is_valid())
          self.assertEqual(serializer.validated_data['country'], 'GB')
  
      def test_deserialize_by_name(self):
          serializer = PersonSerializer(data={
              'name': 'Chris',
              'country': 'New Zealand',
              'fantasy_country': 'Neverland',
          })
          self.assertTrue(serializer.is_valid())
          self.assertEqual(serializer.validated_data['country'], 'NZ')
          self.assertEqual(serializer.validated_data['fantasy_country'], 'NV')
  
      def test_deserialize_invalid(self):
          serializer = PersonSerializer(data={
              'name': 'Chris',
              'country': 'No Such Zealand',
              'fantasy_country': 'Neverland',
          })
          self.assertFalse(serializer.is_valid())
          self.assertTrue(
              serializer.errors['country'],
              ['"No Such Zealand" is not a valid choice.'])
  
      def test_multi_serialize(self):
          mc = MultiCountry(countries='NZ,AU')
          serializer = MultiCountrySerializer(mc)
          self.assertEqual(
              serializer.data,
              {
                  'countries': ['NZ', 'AU']
              })
  
      def test_multi_serialize_empty(self):
          mc = MultiCountry(countries='')
          serializer = MultiCountrySerializer(mc)
          self.assertEqual(
              serializer.data,
              {
                  'countries': []
              })
  
      def test_multi_deserialize(self):
          serializer = MultiCountrySerializer(data={
              'countries': ['NZ', 'AU']
          })
          self.assertTrue(serializer.is_valid())
          self.assertEqual(serializer.validated_data['countries'], ['NZ', 'AU'])
  
      def test_multi_deserialize_by_name(self):
          serializer = MultiCountrySerializer(data={
              'countries': ['New Zealand', 'Australia']
          })
          self.assertTrue(serializer.is_valid())
          self.assertEqual(serializer.validated_data['countries'], ['NZ', 'AU'])
  
      def test_multi_deserialize_invalid(self):
          serializer = MultiCountrySerializer(data={
              'countries': ['NZ', 'BAD', 'AU']
          })
          self.assertFalse(serializer.is_valid())
          errors = serializer.errors['countries']
          if isinstance(errors, dict):
              # djangorestframework >= 3.8.0 returns errors as dict
              # with integers as keys
              errors = errors[1]
          self.assertEqual(errors, ['"BAD" is not a valid choice.'])
  
      def test_multi_deserialize_save(self):
          serializer = MultiCountrySerializer(data={
              'countries': ['NZ', 'AU']
          })
          self.assertTrue(serializer.is_valid())
          saved = serializer.save()
          loaded = MultiCountry.objects.get(pk=saved.pk)
          self.assertEqual(loaded.countries, [Country('NZ'), Country('AU')])
  
  
  class TestDRFMetadata(TestCase):
      """
      Tests against the DRF OPTIONS API metadata endpoint.
      """
  
      def test_actions(self):
  
          class ExampleView(views.APIView):
              """Example view."""
              def post(self, request):
                  pass  # pragma: nocover
  
              def get_serializer(self):
                  return PersonSerializer()
  
          def _choices(response, key):
              """Helper method for unpacking response JSON."""
              return response.data['actions']['POST'][key]['choices']
  
          view = ExampleView.as_view()
  
          factory = APIRequestFactory()
          request = factory.options('/')
          response = view(request=request)
          country_choices = _choices(response, 'country')
          fantasy_choices_en = _choices(response, 'fantasy_country')
          self.assertEqual(response.status_code, 200)
          self.assertEqual(country_choices, countries_display(countries))
          self.assertEqual(
              fantasy_choices_en, countries_display(FantasyCountries()))
  
          with override_settings(LANGUAGE_CODE='fr'):
              response = view(request=request)
              fantasy_choices_fr = _choices(response, 'fantasy_country')
              self.assertNotEqual(fantasy_choices_en, fantasy_choices_fr)
  