RCB-596: Sonar issues. Add coverage for AddressSimilarity.

Author: seth-mg

rosette/api.py

@@ -28,12 +28,16 @@
 import requests
 import platform
 
+_APPLICATION_JSON = 'application/json'
+_BINDING_LANGUAGE = 'python'
 _BINDING_VERSION = '1.14.4'
+_CONCURRENCY_HEADER = 'x-rosetteapi-concurrency'
+_CUSTOM_HEADER_PREFIX = 'X-RosetteAPI-'
+_CUSTOM_HEADER_PATTERN = re.compile('^' + _CUSTOM_HEADER_PREFIX)
 _GZIP_BYTEARRAY = bytearray([0x1F, 0x8b, 0x08])
 
 _ISPY3 = sys.version_info[0] == 3
 
-
 if _ISPY3:
     _GZIP_SIGNATURE = _GZIP_BYTEARRAY
 else:
@@ -49,7 +53,6 @@ def __init__(self, js, code):
         self.status_code = code
 
     def json(self):
-        """ return  json"""
         return self._json
 
 
@@ -112,7 +115,7 @@ def serialize(self, options):
         values = {}
         for (key, val) in self.__params.items():
             if val is None:
-                pass
+                continue
             else:
                 values[key] = val
 
@@ -242,7 +245,7 @@ def validate(self):
             if self[option] is None:
                 raise RosetteException(
                     "missingParameter",
-                    "Required Name Translation parameter, " + option + ", not supplied",
+                    "Required Name Translation parameter is missing: " + option,
                     repr(option))
 
 
@@ -268,7 +271,7 @@ def validate(self):
             if self[option] is None:
                 raise RosetteException(
                     "missingParameter",
-                    "Required Address Similarity parameter, " + option + ", not supplied",
+                    "Required Address Similarity parameter is missing: " + option,
                     repr(option))
 
 
@@ -301,7 +304,7 @@ def validate(self):
             if self[option] is None:
                 raise RosetteException(
                     "missingParameter",
-                    "Required Name Similarity parameter, " + option + ", not supplied",
+                    "Required Name Similarity parameter is missing: " + option,
                     repr(option))
 
 
@@ -321,7 +324,7 @@ def validate(self):
         if self["names"] is None:  # required
             raise RosetteException(
                 "missingParameter",
-                "Required Name De-Duplication parameter, names, not supplied",
+                "Required Name De-Duplication parameter is missing: names",
                 repr("names"))
 
 
@@ -372,31 +375,37 @@ def __finish_result(self, response, ename):
             raise RosetteException(code, complaint_url +
                                    " : failed to communicate with Rosette", msg)
 
-    def info(self):
-        """Issues an "info" request to the L{EndpointCaller}'s specific endpoint.
-        @return: A dictionary telling server version and other
-        identifying data."""
-        url = self.service_url + self.api.endpoints["INFO"]
-        headers = {'Accept': 'application/json', 'X-RosetteAPI-Binding': 'python',
-                   'X-RosetteAPI-Binding-Version': _BINDING_VERSION}
+    def __set_headers(self):
+        headers = {'Accept': _APPLICATION_JSON,
+                   _CUSTOM_HEADER_PREFIX + 'Binding': _BINDING_LANGUAGE,
+                   _CUSTOM_HEADER_PREFIX + 'Binding-Version': _BINDING_VERSION}
 
         custom_headers = self.api.get_custom_headers()
-        pattern = re.compile('^X-RosetteAPI-')
         if custom_headers is not None:
             for key in custom_headers.keys():
-                if pattern.match(key) is not None:
+                if _CUSTOM_HEADER_PATTERN.match(key) is not None:
                     headers[key] = custom_headers[key]
                 else:
                     raise RosetteException("badHeader",
-                                           "Custom header name must begin with \"X-RosetteAPI-\"",
+                                           "Custom header name must begin with \"" + _CUSTOM_HEADER_PREFIX + "\"",
                                            key)
             self.api.clear_custom_headers()
 
         if self.debug:
-            headers['X-RosetteAPI-Devel'] = 'true'
-        self.logger.info('info: ' + url)
+            headers[_CUSTOM_HEADER_PREFIX + 'Devel'] = 'true'
+
         if self.user_key is not None:
-            headers["X-RosetteAPI-Key"] = self.user_key
+            headers[_CUSTOM_HEADER_PREFIX + "Key"] = self.user_key
+
+        return headers
+
+    def info(self):
+        """Issues an "info" request to the L{EndpointCaller}'s specific endpoint.
+        @return: A dictionary telling server version and other
+        identifying data."""
+        url = self.service_url + self.api.endpoints["INFO"]
+        headers = self.__set_headers()
+        self.logger.info('info: ' + url)
         response = self.api.get_http(url, headers=headers)
         return self.__finish_result(response, "info")
 
@@ -407,26 +416,8 @@ def ping(self):
         signalled."""
 
         url = self.service_url + self.api.endpoints['PING']
-        headers = {'Accept': 'application/json', 'X-RosetteAPI-Binding': 'python',
-                   'X-RosetteAPI-Binding-Version': _BINDING_VERSION}
-
-        custom_headers = self.api.get_custom_headers()
-        pattern = re.compile('^X-RosetteAPI-')
-        if custom_headers is not None:
-            for key in custom_headers.keys():
-                if pattern.match(key) is not None:
-                    headers[key] = custom_headers[key]
-                else:
-                    raise RosetteException("badHeader",
-                                           "Custom header name must begin with \"X-RosetteAPI-\"",
-                                           key)
-            self.api.clear_custom_headers()
-
-        if self.debug:
-            headers['X-RosetteAPI-Devel'] = 'true'
+        headers = self.__set_headers()
         self.logger.info('Ping: ' + url)
-        if self.user_key is not None:
-            headers["X-RosetteAPI-Key"] = self.user_key
         response = self.api.get_http(url, headers=headers)
         return self.__finish_result(response, "ping")
 
@@ -454,9 +445,9 @@ def call(self, parameters):
 
         if not isinstance(parameters, _DocumentParamSetBase):
             if self.suburl != self.api.endpoints['NAME_SIMILARITY'] \
-               and self.suburl != self.api.self.api.endpoints['NAME_TRANSLATION'] \
-               and self.suburl != self.api.self.api.endpoints['NAME_DEDUPLICATION'] \
-               and self.suburl != self.api.self.api.endpoints['ADDRESS_SIMILARITY']:
+                    and self.suburl != self.api.self.api.endpoints['NAME_TRANSLATION'] \
+                    and self.suburl != self.api.self.api.endpoints['NAME_DEDUPLICATION'] \
+                    and self.suburl != self.api.self.api.endpoints['ADDRESS_SIMILARITY']:
                 text = parameters
                 parameters = DocumentParameters()
                 parameters['content'] = text
@@ -471,22 +462,7 @@ def call(self, parameters):
         params_to_serialize = parameters.serialize(self.api.options)
         headers = {}
         if self.user_key is not None:
-            custom_headers = self.api.get_custom_headers()
-            pattern = re.compile('^X-RosetteAPI-')
-            if custom_headers is not None:
-                for key in custom_headers.keys():
-                    if pattern.match(key) is not None:
-                        headers[key] = custom_headers[key]
-                    else:
-                        raise RosetteException("badHeader",
-                                               "Custom header name must "
-                                               "begin with \"X-RosetteAPI-\"",
-                                               key)
-                self.api.clear_custom_headers()
-
-            headers["X-RosetteAPI-Key"] = self.user_key
-            headers["X-RosetteAPI-Binding"] = "python"
-            headers["X-RosetteAPI-Binding-Version"] = _BINDING_VERSION
+            headers = self.__set_headers()
 
         if self.use_multipart:
             payload = None
@@ -496,7 +472,7 @@ def call(self, parameters):
             params = dict(
                 (key,
                  value) for key,
-                value in params_to_serialize.items() if key == 'language')
+                            value in params_to_serialize.items() if key == 'language')
             files = {
                 'content': (
                     os.path.basename(
@@ -506,7 +482,7 @@ def call(self, parameters):
                 'request': (
                     'request_options',
                     json.dumps(params),
-                    'application/json')}
+                    _APPLICATION_JSON)}
             request = requests.Request(
                 'POST', url, files=files, headers=headers, params=payload)
             prepared_request = self.api.session.prepare_request(request)
@@ -519,11 +495,11 @@ def call(self, parameters):
                 _my_loads(rdata, response_headers), status)
         else:
             if self.debug:
-                headers['X-RosetteAPI-Devel'] = True
+                headers[_CUSTOM_HEADER_PREFIX + 'Devel'] = True
             self.logger.info('operate: ' + url)
-            headers['Accept'] = "application/json"
+            headers['Accept'] = _APPLICATION_JSON
             headers['Accept-Encoding'] = "gzip"
-            headers['Content-Type'] = "application/json"
+            headers['Content-Type'] = _APPLICATION_JSON
             response = self.api.post_http(url, params_to_serialize, headers)
         return self.__finish_result(response, "operate")
 
@@ -625,6 +601,10 @@ def set_pool_size(self, new_pool_size):
         else:
             self.session.mount('http://', adapter)
 
+    def __adjust_concurrency(self, dict_headers):
+        if _CONCURRENCY_HEADER in dict_headers and dict_headers[_CONCURRENCY_HEADER] != self.max_pool_size:
+            self.set_pool_size(dict_headers[_CONCURRENCY_HEADER])
+
     def _make_request(self, operation, url, data, headers):
         """
         @param operation: POST or GET
@@ -654,9 +634,8 @@ def _make_request(self, operation, url, data, headers):
             status = response.status_code
             rdata = response.content
             dict_headers = dict(response.headers)
+            self.__adjust_concurrency(dict_headers)
             response_headers = {"responseHeaders": dict_headers}
-            if 'x-rosetteapi-concurrency' in dict_headers and dict_headers['x-rosetteapi-concurrency'] != self.max_pool_size:
-                    self.set_pool_size(dict_headers['x-rosetteapi-concurrency'])
 
             if status == 200:
                 return rdata, status, response_headers
@@ -672,9 +651,11 @@ def _make_request(self, operation, url, data, headers):
                         if not message:
                             message = rdata
                     raise RosetteException(code, message, url)
-
-                except:
-                    raise
+                except json.JSONDecodeError as exception:
+                    raise RosetteException(
+                        exception,
+                        "Problem decoding JSON",
+                        rdata)
         except requests.exceptions.RequestException as exception:
             raise RosetteException(
                 exception,

tests/test_rosette_api.py

@@ -23,12 +23,12 @@
 import platform
 import httpretty
 import pytest
-from rosette.api import(API,
-                        DocumentParameters,
-                        NameTranslationParameters,
-                        NameSimilarityParameters,
-                        NameDeduplicationParameters,
-                        RosetteException)
+from rosette.api import (API,
+                         DocumentParameters,
+                         NameTranslationParameters,
+                         NameSimilarityParameters,
+                         NameDeduplicationParameters,
+                         RosetteException, AddressSimilarityParameters)
 
 _ISPY3 = sys.version_info[0] == 3
 
@@ -118,7 +118,7 @@ def test_custom_header_props(api):
     assert value == api.get_custom_headers()[key]
 
     api.clear_custom_headers()
-    assert len(api.get_custom_headers()) is 0
+    assert len(api.get_custom_headers()) == 0
 
 # Test for invalid header name
 
@@ -460,10 +460,10 @@ def test_name_deduplicatation_parameters(api, json_response):
     params = NameDeduplicationParameters()
 
     with pytest.raises(RosetteException) as e_rosette:
-        result = api.name_deduplication(params)
+        api.name_deduplication(params)
 
     assert e_rosette.value.status == 'missingParameter'
-    assert e_rosette.value.message == 'Required Name De-Duplication parameter, names, not supplied'
+    assert e_rosette.value.message == 'Required Name De-Duplication parameter is missing: names'
 
     params["names"] = ["John Smith", "Johnathon Smith", "Fred Jones"]
 
@@ -572,6 +572,43 @@ def test_for_no_content_or_contentUri(api, json_response, doc_params):
     httpretty.disable()
     httpretty.reset()
 
+
+def test_for_address_similarity_required_parameters(api, json_response):
+    """Test address similarity parameters"""
+    httpretty.enable()
+    httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/info",
+                           body=json_response, status=200, content_type="application/json")
+    httpretty.register_uri(httpretty.POST, "https://api.rosette.com/rest/v1/address-similarity",
+                           body=json_response, status=200, content_type="application/json")
+
+    params = AddressSimilarityParameters()
+
+    with pytest.raises(RosetteException) as e_rosette:
+        api.address_similarity(params)
+
+    assert e_rosette.value.status == 'missingParameter'
+    assert e_rosette.value.message == 'Required Address Similarity parameter is missing: address1'
+
+    params["address1"] = {"houseNumber": "1600",
+                          "road": "Pennsylvania Ave NW",
+                          "city": "Washington",
+                          "state": "DC",
+                          "postCode": "20500"}
+
+    with pytest.raises(RosetteException) as e_rosette:
+        api.address_similarity(params)
+
+    assert e_rosette.value.status == 'missingParameter'
+    assert e_rosette.value.message == 'Required Address Similarity parameter is missing: address2'
+
+    params["address2"] = {"text": "160 Pennsilvana Avenue, Washington, D.C., 20500"}
+
+    result = api.address_similarity(params)
+    assert result["name"] == "Rosette"
+    httpretty.disable()
+    httpretty.reset()
+
+
 # Test for required Name Similarity parameters
 
 
@@ -588,20 +625,20 @@ def test_for_name_similarity_required_parameters(api, json_response):
     params = NameSimilarityParameters()
 
     with pytest.raises(RosetteException) as e_rosette:
-        result = api.name_similarity(params)
+        api.name_similarity(params)
 
     assert e_rosette.value.status == 'missingParameter'
-    assert e_rosette.value.message == 'Required Name Similarity parameter, name1, not supplied'
+    assert e_rosette.value.message == 'Required Name Similarity parameter is missing: name1'
 
     params["name1"] = {
         "text": matched_name_data1,
         "language": "eng",
         "entityType": "PERSON"}
     with pytest.raises(RosetteException) as e_rosette:
-        result = api.name_similarity(params)
+        api.name_similarity(params)
 
     assert e_rosette.value.status == 'missingParameter'
-    assert e_rosette.value.message == 'Required Name Similarity parameter, name2, not supplied'
+    assert e_rosette.value.message == 'Required Name Similarity parameter is missing: name2'
 
     params["name2"] = {"text": matched_name_data2, "entityType": "PERSON"}
 
@@ -626,19 +663,18 @@ def test_for_name_translation_required_parameters(api, json_response):
     params["targetScript"] = "Latn"
 
     with pytest.raises(RosetteException) as e_rosette:
-        result = api.name_translation(params)
+        api.name_translation(params)
 
     assert e_rosette.value.status == 'missingParameter'
-    assert e_rosette.value.message == 'Required Name Translation parameter, name, not supplied'
+    assert e_rosette.value.message == 'Required Name Translation parameter is missing: name'
 
     params["name"] = "some data to translate"
 
     with pytest.raises(RosetteException) as e_rosette:
-        result = api.name_translation(params)
+        api.name_translation(params)
 
     assert e_rosette.value.status == 'missingParameter'
-    assert e_rosette.value.message == ('Required Name Translation parameter, '
-                                       'targetLanguage, not supplied')
+    assert e_rosette.value.message == 'Required Name Translation parameter is missing: targetLanguage'
 
     params["targetLanguage"] = "eng"