Added raise_for_status method when database or document does not exist and status code is not 404

- Added missing instances of raise_for_status after calling HTTP requests

Author: emlaver

CHANGES.rst

@@ -1,5 +1,6 @@
 2.2.0 (Unreleased)
 ==================
+- [FIXED] HTTPError is raised when 4xx or 5xx codes are encountered
 
 2.1.0 (2016-08-31)
 ==================

src/cloudant/database.py

@@ -101,7 +101,10 @@ def exists(self):
 
         :returns: Boolean True if the database exists, False otherwise
         """
-        resp = self.r_session.get(self.database_url)
+        resp = self.r_session.head(self.database_url)
+        if resp.status_code not in [200, 404]:
+            resp.raise_for_status()
+
         return resp.status_code == 200
 
     def metadata(self):
@@ -891,6 +894,7 @@ def update_handler_result(self, ddoc_id, handler_name, doc_id=None, data=None, *
             resp = self.r_session.post(
                 '/'.join([ddoc.document_url, '_update', handler_name]),
                 params=params, data=data)
+        resp.raise_for_status()
         return resp.text
 
 class CloudantDatabase(CouchDatabase):

src/cloudant/design_document.py

@@ -715,6 +715,7 @@ def info(self):
         """
         ddoc_info = self.r_session.get(
             '/'.join([self.document_url, '_info']))
+        ddoc_info.raise_for_status()
         return ddoc_info.json()
 
     def search_info(self, search_index):
@@ -726,4 +727,5 @@ def search_info(self, search_index):
         """
         ddoc_search_info = self.r_session.get(
             '/'.join([self.document_url, '_search_info', search_index]))
+        ddoc_search_info.raise_for_status()
         return ddoc_search_info.json()

src/cloudant/document.py

@@ -101,7 +101,11 @@ def exists(self):
         """
         if self._document_id is None:
             return False
-        resp = self.r_session.get(self.document_url)
+        else:
+            resp = self.r_session.head(self.document_url)
+            if resp.status_code not in [200, 404]:
+                resp.raise_for_status()
+
         return resp.status_code == 200
 
     def json(self):

tests/unit/database_tests.py

@@ -23,6 +23,7 @@
 """
 
 import unittest
+import mock
 import requests
 import posixpath
 import os
@@ -92,13 +93,28 @@ def test_retrieve_creds(self):
 
     def test_exists(self):
         """
-        Test database exists fucntionality
+        Tests that the result of True is expected when the database exists,
+        and False is expected when the database is nonexistent remotely.
         """
         self.assertTrue(self.db.exists())
         # Construct a database object that does not exist remotely
         fake_db = self.client._DATABASE_CLASS(self.client, 'no-such-db')
         self.assertFalse(fake_db.exists())
 
+    def test_exists_raises_httperror(self):
+        """
+        Test database exists raises an HTTPError.
+        """
+        # Mock HTTPError when running against CouchDB and Cloudant
+        resp = requests.Response()
+        resp.status_code = 400
+        self.client.r_session.head = mock.Mock(return_value=resp)
+        with self.assertRaises(requests.HTTPError) as cm:
+            self.db.exists()
+        err = cm.exception
+        self.assertEqual(err.response.status_code, 400)
+        self.client.r_session.head.assert_called_with(self.db.database_url)
+
     def test_create_db_delete_db(self):
         """
         Test creating and deleting a database
@@ -749,6 +765,26 @@ def test_update_doc_with_update_handler(self):
              'message': 'hello'}
         )
 
+    def test_update_handler_raises_httperror(self):
+        """
+        Test update_handler_result raises an HTTPError.
+        """
+        # Mock HTTPError when running against CouchDB or Cloudant
+        resp = requests.Response()
+        resp.status_code = 400
+        self.client.r_session.put = mock.Mock(return_value=resp)
+        with self.assertRaises(requests.HTTPError) as cm:
+            self.db.update_handler_result('ddoc001', 'update001', 'julia001',
+                                          field='new_field', value='new_value',
+                                          data={'message': 'hello'})
+        err = cm.exception
+        self.assertEqual(err.response.status_code, 400)
+        ddoc = DesignDocument(self.db, 'ddoc001')
+        self.client.r_session.put.assert_called_with(
+            '/'.join([ddoc.document_url, '_update', 'update001', 'julia001']),
+            data={'message': 'hello'},
+            params={'field': 'new_field', 'value': 'new_value'})
+
 @unittest.skipUnless(
     os.environ.get('RUN_CLOUDANT_TESTS') is not None,
     'Skipping Cloudant specific Database tests'

tests/unit/design_document_tests.py

@@ -24,6 +24,8 @@
 import json
 import os
 import unittest
+import mock
+import requests
 
 from cloudant.document import Document 
 from cloudant.design_document import DesignDocument
@@ -754,6 +756,22 @@ def test_get_info(self):
              'name': name
             })
 
+    def test_get_info_raises_httperror(self):
+        """
+        Test get_info raises an HTTPError.
+        """
+        # Mock HTTPError when running against CouchDB and Cloudant
+        resp = requests.Response()
+        resp.status_code = 400
+        self.client.r_session.get = mock.Mock(return_value=resp)
+        ddoc = DesignDocument(self.db, '_design/ddoc001')
+        with self.assertRaises(requests.HTTPError) as cm:
+            ddoc.info()
+        err = cm.exception
+        self.assertEqual(err.response.status_code, 400)
+        self.client.r_session.get.assert_called_with(
+            '/'.join([ddoc.document_url, '_info']))
+
     @unittest.skipUnless(
         os.environ.get('RUN_CLOUDANT_TESTS') is not None,
         'Skipping Cloudant _search_info endpoint test'
@@ -781,6 +799,27 @@ def test_get_search_info(self):
                               'pending_seq': 101, 'committed_seq': 0},
              })
 
+    @unittest.skipUnless(
+        os.environ.get('RUN_CLOUDANT_TESTS') is not None,
+        'Skipping Cloudant _search_info raises HTTPError test'
+    )
+    def test_get_search_info_raises_httperror(self):
+        """
+        Test get_search_info raises an HTTPError.
+        """
+        # Mock HTTPError when running against Cloudant
+        search_index = 'search001'
+        resp = requests.Response()
+        resp.status_code = 400
+        self.client.r_session.get = mock.Mock(return_value=resp)
+        ddoc = DesignDocument(self.db, '_design/ddoc001')
+        with self.assertRaises(requests.HTTPError) as cm:
+            ddoc.search_info(search_index)
+        err = cm.exception
+        self.assertEqual(err.response.status_code, 400)
+        self.client.r_session.get.assert_called_with(
+            '/'.join([ddoc.document_url, '_search_info', search_index]))
+
     def test_add_a_search_index(self):
         """
         Test that adding a search index adds a search index object to

tests/unit/document_tests.py

@@ -23,6 +23,7 @@
 """
 
 import unittest
+import mock
 import posixpath
 import json
 import requests
@@ -128,7 +129,8 @@ def test_constructor_without_docid(self):
 
     def test_document_exists(self):
         """
-        Test whether a document exists remotely
+        Tests that the result of True is expected when the document exists,
+        and False is expected when the document is nonexistent remotely.
         """
         doc = Document(self.db)
         self.assertFalse(doc.exists())
@@ -137,6 +139,22 @@ def test_document_exists(self):
         doc.create()
         self.assertTrue(doc.exists())
 
+    def test_document_exists_raises_httperror(self):
+        """
+        Test document exists raises an HTTPError.
+        """
+        # Mock HTTPError when running against CouchDB and Cloudant
+        resp = requests.Response()
+        resp.status_code = 400
+        self.client.r_session.head = mock.Mock(return_value=resp)
+        doc = Document(self.db)
+        doc['_id'] = 'julia006'
+        with self.assertRaises(requests.HTTPError) as cm:
+            doc.exists()
+        err = cm.exception
+        self.assertEqual(err.response.status_code, 400)
+        self.client.r_session.head.assert_called_with(doc.document_url)
+
     def test_retrieve_document_json(self):
         """
         Test the document dictionary renders as json appropriately