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_to_native_request_GET(self):
     request = Request(self.factory.get('/'))
     mock_serializer = Serializer()
     mock_serializer.context = {'request': request}
     field = self.field_class()
     field.initialize(mock_serializer, 'name')
     self._test_expected_dict(field)

 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 __init__(self, *args, **kwargs):
     Serializer.__init__(self, *args, **kwargs)
     ctx = kwargs.get("context", {})
     columns = ctx.get("columns", [])
     queries = ctx.get("queries", None)
     
     if "hits" in columns and queries:
         for q in queries:
             self.fields[q.label] = ScoreField()
     if "text" in columns:
         self.fields['text'] = CharField()
     if "lead" in columns:
         self.fields['lead'] = HighlightField()

 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 = self.field_class()
     field.initialize(mock_serializer, 'name')
     self._test_expected_single_string(field)

 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 __init__(self, *args, **kwargs):
        Serializer.__init__(self, *args, **kwargs)
        ctx = kwargs.get("context", {})
        columns = set(ctx.get("columns", []))
        if not columns:
            columns = self.default_columns
        queries = ctx.get("queries", [])
        if ctx.get('minimal'):
            for fn in list(self.fields):
                if fn != 'id' and fn not in columns:
                    del self.fields[fn]


        for column in columns:
            if column not in self.fields:
                self.fields[column] = CharField()

        if "hits" in columns and queries:
            for q in queries:
                self.fields[q.label] = ScoreField()

        if "text" in columns:
            self.fields['text'] = CharField()

        if "date" in columns:
            self.fields['date'] =  DateTimeField(input_formats=("iso-8601",))

        if "projectid" in columns:
            self.fields['projectid'] = IntegerField()

        if "lead" in columns:
            self.fields['lead'] = HighlightField()

        if "kwic" in columns:
            self.fields['left'] = KWICField(kwic='left')
            self.fields['keyword'] = KWICField(kwic='keyword')
            self.fields['right'] = KWICField(kwic='right')

    def __init__(self, *args, **kwargs):
        Serializer.__init__(self, *args, **kwargs)
        ctx = kwargs.get("context", {})
        columns = ctx.get("columns", [])
        queries = ctx.get("queries", [])

        if ctx.get('minimal'):
            for fn in list(self.fields):
                if fn != 'id' and fn not in list(columns):
                    del self.fields[fn]

        if "hits" in columns and queries:
            for q in queries:
                self.fields[q.label] = ScoreField()
        if "text" in columns:
            self.fields['text'] = CharField()
        if "projectid" in columns:
            self.fields['projectid'] = IntegerField()
        if "lead" in columns:
            self.fields['lead'] = HighlightField()
        if "kwic" in columns:
            self.fields['left'] = KWICField(kwic='left')
            self.fields['keyword'] = KWICField(kwic='keyword')
            self.fields['right'] = KWICField(kwic='right')

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

 def __init__(self, *args, **kwargs):
     Serializer.__init__(self, *args, **kwargs)
     for x in kwargs["context"]["axes"]:
         self.fields[x] = CharField()

 def test_get_attribute_request_GET(self):
     request = Request(self.factory.get('/'))
     mock_serializer = Serializer()
     mock_serializer.context = {'request': request}
     field = self.field_class()
     self._test_expected_dict(field)

 def test_get_attribute_empty_context(self):
     mock_serializer = Serializer()
     mock_serializer.context = {}
     field = self.field_class()
     self._test_expected_dict(field, mock_serializer)

 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_to_native_request_POST(self):
     request = Request(self.factory.post('/'))
     mock_serializer = Serializer()
     mock_serializer.context = {'request': request}
     field = self.field_class()
     self._test_expected_dict(field)

 def test_field_to_native_empty_context(self):
     mock_serializer = Serializer()
     mock_serializer.context = {}
     field = self.field_class()
     self._test_expected_dict(field, mock_serializer)