class VersioningParserIntegrationTests(TestCase):
    def setUp(self):
        self.request = APIRequestFactory().get('')
        self.request.version = 1
        self.parser = TestParser()
        self.json_string = json.dumps(
            {
                'test_field_one': 'value_one',
                'test_field_two': 'value_two',
                'test_field_three': 'value_three',
                'test_field_four': 'value_four',
                'test_field_five': 'value_five',
            },
        )
        self.json_string_data = io.BytesIO(str.encode(self.json_string))

    def test_parsing_does_forward_conversion_v1_to_v3(self):
        data_dict = self.parser.parse(
            stream=self.json_string_data,
            media_type='application/vnd.test.testtype+json',
            parser_context={
                'request': self.request,
            },
        )
        self.assertTrue('new_test_field' in data_dict)
        self.assertEqual(data_dict['new_test_field'], 'value_one')
        self.assertTrue('new_related_object_id_list' in data_dict)
        self.assertEqual(data_dict['new_related_object_id_list'], [1, 2, 3, 4, 5])
class VersioningParserIntegrationTests(TestCase):
    def setUp(self):
        self.request = APIRequestFactory().get("")
        self.request.version = 1
        self.parser = TestParser()
        self.json_string = json.dumps(
            {
                "test_field_one": "value_one",
                "test_field_two": "value_two",
                "test_field_three": "value_three",
                "test_field_four": "value_four",
                "test_field_five": "value_five",
            }
        )
        self.json_string_data = io.BytesIO(str.encode(self.json_string))

    def test_parsing_does_forward_conversion_v1_to_v3(self):
        data_dict = self.parser.parse(
            stream=self.json_string_data,
            media_type="application/vnd.test.testtype+json",
            parser_context={"request": self.request},
        )
        self.assertTrue("new_test_field" in data_dict)
        self.assertEqual(data_dict["new_test_field"], "value_one")
        self.assertTrue("new_related_object_id_list" in data_dict)
        self.assertEqual(data_dict["new_related_object_id_list"], [1, 2, 3, 4, 5])
 def setUp(self):
     self.request = APIRequestFactory().get('')
     self.request.version = 1
     self.parser = TestParser()
     self.json_string = json.dumps(
         {
             'test_field_one': 'value_one',
             'test_field_two': 'value_two',
             'test_field_three': 'value_three',
             'test_field_four': 'value_four',
             'test_field_five': 'value_five',
         },
     )
     self.json_string_data = io.BytesIO(str.encode(self.json_string))
 def setUp(self):
     self.request = APIRequestFactory().get("")
     self.request.version = 1
     self.parser = TestParser()
     self.json_string = json.dumps(
         {
             "test_field_one": "value_one",
             "test_field_two": "value_two",
             "test_field_three": "value_three",
             "test_field_four": "value_four",
             "test_field_five": "value_five",
         }
     )
     self.json_string_data = io.BytesIO(str.encode(self.json_string))
class VersioningParserUnitTests(TestCase):
    def setUp(self):
        self.request = APIRequestFactory().get('')
        self.request.version = 1
        self.parser = TestParser()
        self.json_string = json.dumps(
            {
                'test_field_one': 'value_one',
                'test_field_two': 'value_two',
                'test_field_three': 'value_three',
                'test_field_four': 'value_four',
                'test_field_five': 'value_five',
            },
        )
        self.json_string_data = io.BytesIO(str.encode(self.json_string))

    def test_parse_raises_error_when_no_transform_base_specified(self):
        self.parser.transform_base = None
        with self.assertRaises(TransformBaseNotDeclaredException):
            self.parser.parse(stream=None)

    def test_unversioned_request_returns_default_parsed_data(self):
        self.request = APIRequestFactory().get('')
        data_dict = self.parser.parse(
            stream=self.json_string_data,
            media_type='application/vnd.test.testtype+json',
            parser_context={
                'request': self.request,
            },
        )
        self.json_string_data = io.BytesIO(str.encode(self.json_string))
        default_data_dict = JSONParser().parse(
            stream=self.json_string_data,
            media_type='application/vnd.test.testtype+json',
            parser_context={
                'request': self.request,
            },
        )
        self.assertEqual(data_dict, default_data_dict)

    @patch('rest_framework_transforms.parsers.get_transform_classes')
    def test_parse_gets_transform_classes_with_version_specified(self, get_transform_classes_mock):
        self.parser.parse(
            stream=self.json_string_data,
            media_type='application/vnd.test.testtype+json',
            parser_context={
                'request': self.request,
            },
        )
        self.assertTrue(get_transform_classes_mock.called)
        get_transform_classes_mock.assert_called_once_with(
            'tests.test_transforms.TestModelTransform',
            base_version=self.request.version,
            reverse=False,
        )

    @patch('rest_framework_transforms.parsers.get_transform_classes')
    def test_parse_doesnt_get_transform_classes_with_no_version_specified(self, get_transform_classes_mock):
        self.request = APIRequestFactory().get('')
        self.parser.parse(
            stream=self.json_string_data,
            media_type='application/vnd.test.testtype+json',
            parser_context={
                'request': self.request,
            },
        )
        self.assertFalse(get_transform_classes_mock.called)

    @patch('rest_framework_transforms.parsers.get_transform_classes')
    def test_parse_calls_forwards_on_transform_classes(self, get_transform_classes_mock):
        transform_one = MagicMock()
        transform_two = MagicMock()
        get_transform_classes_mock.return_value = [
            transform_one,
            transform_two,
        ]

        self.parser.parse(
            stream=self.json_string_data,
            media_type='application/vnd.test.testtype+json',
            parser_context={
                'request': self.request,
            },
        )

        self.json_string_data = io.BytesIO(str.encode(self.json_string))
        self.assertTrue(transform_one.return_value.forwards.called)
        transform_one.return_value.forwards.assert_called_once_with(
            data=JSONParser().parse(
                stream=self.json_string_data,
                media_type='application/vnd.test.testtype+json',
                parser_context={
                    'request': self.request,
                },
            ),
            request=self.request,
        )

        self.assertTrue(transform_two.return_value.forwards.called)
        transform_two.return_value.forwards.assert_called_once_with(
            data=transform_one.return_value.forwards.return_value,
            request=self.request,
        )