Issue #20

CHANGELOG.rst

@@ -4,6 +4,9 @@ Changelog
 0.7.3 (2014-03-XX)
 ++++++++++++++++++
 
+- Fixed: `Issue #20 <https://github.com/maxtepkeev/python-redmine/issues/20>`__ (Lowered
+  Requests version requirements. Python Redmine now requires Requests starting from 0.12.1
+  instead of 2.1.0 in previous versions
 - Fixed: `Issue #23 <https://github.com/maxtepkeev/python-redmine/issues/23>`__ (File uploads
   via ``update()`` method didn't work
 

redmine/__init__.py

@@ -3,7 +3,7 @@
 from distutils.version import LooseVersion
 from redmine.version import __version__
 from redmine.managers import ResourceManager
-from redmine.utilities import to_string
+from redmine.utilities import to_string, json_response
 from redmine.exceptions import (
     AuthError,
     ConflictError,
@@ -79,7 +79,7 @@ def request(self, method, url, headers=None, params=None, data=None):
         if response.status_code in (200, 201):
             if not response.content.strip():
                 return True
-            return response.json()
+            return json_response(response.json)
         elif response.status_code == 401:
             raise AuthError()
         elif response.status_code == 404:
@@ -89,7 +89,7 @@ def request(self, method, url, headers=None, params=None, data=None):
         elif response.status_code == 412 and self.impersonate is not None:
             raise ImpersonateError()
         elif response.status_code == 422:
-            raise ValidationError(to_string(', '.join(response.json()['errors'])))
+            raise ValidationError(to_string(', '.join(json_response(response.json)['errors'])))
         elif response.status_code == 500:
             raise ServerError()
 

redmine/utilities.py

@@ -1,12 +1,19 @@
 import sys
 from string import Formatter
+from distutils.version import LooseVersion
+from requests import __version__ as requests_version
 
 
 def to_string(string):
     """Converts unicode to utf-8 if on Python 2, leaves as is if on Python 3"""
     return string.encode('utf-8') if sys.version_info[0] < 3 else string
 
 
+def json_response(json_):
+    """Requests had json as a property until 1.0.0 and as a method afterwards"""
+    return json_() if LooseVersion(requests_version) >= LooseVersion('1.0.0') else json_
+
+
 class MemorizeFormatter(Formatter):
     """Memorizes all arguments, used during string formatting"""
     def __init__(self):

setup.py

@@ -13,7 +13,7 @@
     description='Library for communicating with a Redmine project management application',
     long_description=open('README.rst').read() + '\n\n' + open('CHANGELOG.rst').read(),
     keywords='redmine',
-    install_requires=['requests >= 2.1.0'],
+    install_requires=['requests >= 0.12.1'],
     zip_safe=False,
     classifiers=[
         'Development Status :: 4 - Beta',

tests/__init__.py

@@ -9,5 +9,12 @@
     import mock
 
 from redmine import Redmine
+from distutils.version import LooseVersion
+from requests import __version__ as requests_version
 
 URL = 'http://foo.bar'
+
+
+def json_response(json_):
+    """Requests had json as a property until 1.0.0 and as a method afterwards"""
+    return mock.Mock(return_value=json_) if LooseVersion(requests_version) >= LooseVersion('1.0.0') else json_

tests/test_managers.py

@@ -1,4 +1,4 @@
-from tests import unittest, mock, Redmine, URL
+from tests import unittest, mock, json_response, Redmine, URL
 from redmine.managers import ResourceManager
 from redmine.resources import Project
 from redmine.resultsets import ResourceSet
@@ -108,7 +108,7 @@ def test_convert_dicts_to_resource_set_object(self):
     @mock.patch('requests.get')
     def test_get_single_resource(self, mock_get):
         mock_get.return_value = response = mock.Mock(status_code=200)
-        response.json.return_value = {'project': {'name': 'Foo', 'identifier': 'foo', 'id': 1}}
+        response.json = json_response({'project': {'name': 'Foo', 'identifier': 'foo', 'id': 1}})
         project = self.redmine.project.get('foo')
         self.assertEqual(project.name, 'Foo')
         self.assertEqual(project.identifier, 'foo')
@@ -132,7 +132,7 @@ def test_prepare_params(self):
     @mock.patch('requests.post')
     def test_create_resource(self, mock_post):
         mock_post.return_value = response = mock.Mock(status_code=201)
-        response.json.return_value = {'user': {'firstname': 'John', 'lastname': 'Smith', 'id': 1}}
+        response.json = json_response({'user': {'firstname': 'John', 'lastname': 'Smith', 'id': 1}})
         user = self.redmine.user.create(firstname='John', lastname='Smith')
         self.assertEqual(user.firstname, 'John')
         self.assertEqual(user.lastname, 'Smith')
@@ -141,10 +141,10 @@ def test_create_resource(self, mock_post):
     @mock.patch('requests.post')
     def test_create_resource_with_uploads(self, mock_post):
         mock_post.return_value = response = mock.Mock(status_code=201)
-        response.json.return_value = {
+        response.json = json_response({
             'upload': {'token': '123456'},
             'issue': {'subject': 'Foo', 'project_id': 1, 'id': 1}
-        }
+        })
         issue = self.redmine.issue.create(project_id=1, subject='Foo', uploads=[{'path': 'foo'}])
         self.assertEqual(issue.project_id, 1)
         self.assertEqual(issue.subject, 'Foo')
@@ -169,7 +169,7 @@ def test_update_resource(self, mock_put):
     def test_update_resource_with_uploads(self, mock_post, mock_put):
         mock_put.return_value = mock.Mock(status_code=200, content='')
         mock_post.return_value = response = mock.Mock(status_code=201)
-        response.json.return_value = {'upload': {'token': '123456'}}
+        response.json = json_response({'upload': {'token': '123456'}})
         manager = self.redmine.issue
         manager.params['subject'] = 'Foo'
         self.assertEqual(manager.update(1, subject='Bar', uploads=[{'path': 'foo'}]), True)

tests/test_redmine.py

@@ -1,4 +1,4 @@
-from tests import unittest, mock, Redmine, URL
+from tests import unittest, mock, json_response, Redmine, URL
 
 
 class TestRedmine(unittest.TestCase):
@@ -65,13 +65,13 @@ def test_successful_response_via_username_password(self):
         self.redmine.username = 'john'
         self.redmine.password = 'qwerty'
         self.response.status_code = 200
-        self.response.json.return_value = {'success': True}
+        self.response.json = json_response({'success': True})
         self.assertEqual(self.redmine.request('get', self.url)['success'], True)
 
     def test_successful_response_via_api_key(self):
         self.redmine.key = '123'
         self.response.status_code = 200
-        self.response.json.return_value = {'success': True}
+        self.response.json = json_response({'success': True})
         self.assertEqual(self.redmine.request('get', self.url)['success'], True)
 
     def test_successful_response_via_put_method(self):
@@ -82,7 +82,7 @@ def test_successful_response_via_put_method(self):
     @mock.patch('redmine.open', mock.mock_open(), create=True)
     def test_successful_file_upload(self):
         self.response.status_code = 201
-        self.response.json.return_value = {'upload': {'token': '123456'}}
+        self.response.json = json_response({'upload': {'token': '123456'}})
         self.assertEqual(self.redmine.upload('foo'), '123456')
 
     def test_file_upload_no_file_exception(self):
@@ -118,7 +118,7 @@ def test_server_error_exception(self):
     def test_validation_error_exception(self):
         from redmine.exceptions import ValidationError
         self.response.status_code = 422
-        self.response.json.return_value = {'errors': ['foo', 'bar']}
+        self.response.json = json_response({'errors': ['foo', 'bar']})
         self.assertRaises(ValidationError, lambda: self.redmine.request('post', self.url))
 
     def test_not_found_error_exception(self):
@@ -133,5 +133,5 @@ def test_auth(self):
         self.redmine.username = 'john'
         self.redmine.password = 'qwerty'
         self.response.status_code = 200
-        self.response.json.return_value = {'user': {'firstname': 'John', 'lastname': 'Smith', 'id': 1}}
+        self.response.json = json_response({'user': {'firstname': 'John', 'lastname': 'Smith', 'id': 1}})
         self.assertEqual(self.redmine.auth().firstname, 'John')