def test_field_to_native_request_GET(self):
     request = Request(self.factory.get('/'))
     mock_serializer = Serializer()
     mock_serializer.context = {'request': request}
     field = TranslationSerializerField()
     field.initialize(mock_serializer, 'name')
     self._test_expected_dict(field)

    def test_field_to_native(self):
        class TestObject(object):
            test_field = u'Yes We Can'

        field = TranslationSerializerField()
        result = field.field_to_native(TestObject(), 'test_field')
        eq_(result, TestObject.test_field)

 def test_field_to_native_request_POST(self):
     request = Request(self.factory.post("/"))
     mock_serializer = Serializer()
     mock_serializer.context = {"request": request}
     field = TranslationSerializerField()
     field.initialize(mock_serializer, "name")
     self._test_expected_dict(field)

 def test_field_null(self):
     field = TranslationSerializerField()
     app = Webapp()
     result = field.field_to_native(app, "name")
     eq_(result, None)
     result = field.field_to_native(app, "description")
     eq_(result, None)

 def test_field_from_native_strip(self):
     data = {
         'fr': u'  Non mais Allô quoi ! ',
         'en-US': u''
     }
     field = TranslationSerializerField()
     result = field.from_native(data)
     eq_(result, {'fr': u'Non mais Allô quoi !', 'en-US': u''})

 def test_field_to_native_source(self):
     self.app.mymock = Mock()
     self.app.mymock.mymocked_field = self.app.name
     field = TranslationSerializerField(source="mymock.mymocked_field")
     result = field.field_to_native(self.app, "shouldbeignored")
     expected = {
         "en-US": unicode(Translation.objects.get(id=self.app.name.id, locale="en-US")),
         "es": unicode(Translation.objects.get(id=self.app.name.id, locale="es")),
     }
     eq_(result, expected)

 def test_field_to_native_source(self):
     self.app.mymock = Mock()
     self.app.mymock.mymocked_field = self.app.name
     field = TranslationSerializerField(source='mymock.mymocked_field')
     result = field.field_to_native(self.app, 'shouldbeignored')
     expected = {
         'en-US': unicode(Translation.objects.get(id=self.app.name.id,
                                                  locale='en-US')),
         'es': unicode(Translation.objects.get(id=self.app.name.id,
                                               locale='es')),
     }
     eq_(result, expected)

 def get_apps(self, obj):
     """
     Return a list of serialized apps, adding each app's `group` to the
     serialization.
     """
     ret = []
     memberships = FeedCollectionMembership.objects.filter(obj_id=obj.id)
     field = TranslationSerializerField()
     field.initialize(self, 'group')
     field.context = self.context
     for member in memberships:
         data = AppSerializer(member.app, context=self.context).data
         data['group'] = field.field_to_native(member, 'group')
         ret.append(data)
     return ret

 def test_field_to_native_request_GET_lang(self):
     """
     Pass a lang in the query string, expect to have a single string
     returned instead of an object.
     """
     # Note that we don't go through the middlewares etc so the actual
     # language for the process isn't changed, we don't care as
     # _expect_single_string() method simply tests with the current language,
     # whatever it is.
     request = Request(self.factory.get('/', {'lang': 'lol'}))
     eq_(request.GET['lang'], 'lol')
     mock_serializer = Serializer()
     mock_serializer.context = {'request': request}
     field = TranslationSerializerField()
     field.initialize(mock_serializer, 'name')
     self._test_expected_single_string(field)

    def test_field_to_native(self):
        app = Webapp.objects.get(pk=337141)
        field = TranslationSerializerField()
        result = field.field_to_native(app, 'name')
        expected = {
            'en-US': Translation.objects.get(id=app.name.id, locale='en-US'),
            'es': Translation.objects.get(id=app.name.id, locale='es')
        }
        eq_(result, expected)

        result = field.field_to_native(app, 'description')
        expected = {
            'en-US': Translation.objects.get(id=app.description.id, 
                                             locale='en-US'),
        }
        eq_(result, expected)

    def test_from_native(self):
        data = u"Translatiön"
        field = TranslationSerializerField()
        result = field.from_native(data)
        eq_(result, data)

        data = {"fr": u"Non mais Allô quoi !", "en-US": u"No But Hello what!"}
        field = TranslationSerializerField()
        result = field.from_native(data)
        eq_(result, data)

        data = ["Bad Data"]
        field = TranslationSerializerField()
        result = field.from_native(data)
        eq_(result, unicode(data))

 def get_apps(self, obj):
     """
     Return a list of serialized apps, adding each app's `group` to the
     serialization.
     """
     ret = []
     memberships = FeedShelfMembership.objects.filter(obj_id=obj.id)
     field = TranslationSerializerField()
     field.bind('group', self)
     field.context = self.context
     for member in memberships:
         data = AppSerializer(member.app, context=self.context).data
         data['group'] = field.to_representation(
             field.get_attribute(member))
         ret.append(data)
     return ret

    def test_from_native(self):
        data = u'Translatiön'
        field = TranslationSerializerField()
        result = field.from_native(data)
        eq_(result, data)

        data = {
            'fr': u'Non mais Allô quoi !',
            'en-US': u'No But Hello what!'
        }
        field = TranslationSerializerField()
        result = field.from_native(data)
        eq_(result, data)

        data = ['Bad Data']
        field = TranslationSerializerField()
        result = field.from_native(data)
        eq_(result, unicode(data))

 def test_field_to_native_empty_context(self):
     mock_serializer = Serializer()
     mock_serializer.context = {}
     field = TranslationSerializerField()
     field.initialize(mock_serializer, 'name')
     self._test_expected_dict(field)

 def test_field_from_native_strip(self):
     data = {"fr": u"  Non mais Allô quoi ! ", "en-US": u""}
     field = TranslationSerializerField()
     result = field.from_native(data)
     eq_(result, {"fr": u"Non mais Allô quoi !", "en-US": u""})