Code polishing: helpers to validate input, BulkResult class instead of tuple

Author: mredolatti

splitapiclient/microclients/attribute_microclient.py

@@ -2,7 +2,7 @@
 from splitapiclient.util.exceptions import HTTPResponseError, \
     UnknownApiClientError
 from splitapiclient.util.logger import LOGGER
-
+from splitapiclient.util.helpers import as_dict
 
 class AttributeMicroClient:
     '''
@@ -56,18 +56,11 @@ def list(self, traffic_type_id):
             returned
         :rtype: list(TrafficType)
         '''
-        try:
-            response = self._http_client.make_request(
-                self._endpoint['all_items'],
-                trafficTypeId=traffic_type_id
-            )
-            return [Attribute(item, self._http_client) for item in response]
-        except HTTPResponseError as e:
-            LOGGER.error('Error retrieving items')
-            raise e
-        except Exception as e:
-            LOGGER.debug(e)
-            raise UnknownApiClientError()
+        response = self._http_client.make_request(
+            self._endpoint['all_items'],
+            trafficTypeId=traffic_type_id
+        )
+        return [Attribute(item, self._http_client) for item in response]
 
     def save(self, attribute):
         '''
@@ -79,48 +72,35 @@ def save(self, attribute):
         :returns: newly created attribute
         :rtype: Attribute
         '''
-        # TODO: Validate!
-        try:
-            data = attribute.to_dict() if isinstance(attribute, Attribute) else attribute
-            response = self._http_client.make_request(
-                self._endpoint['create'],
-                data,
-                trafficTypeId=data['trafficTypeId']
-            )
+        data = as_dict(attribute)
+        response = self._http_client.make_request(
+            self._endpoint['create'],
+            data,
+            trafficTypeId=data.get('trafficTypeId')
+        )
+        return Attribute(response, self._http_client)
 
-            return Attribute(response, self._http_client)
+    def delete(self, attribute_id, traffic_type_id):
+        '''
+        Delete an attribute by specifying its id and it's traffic type id.
 
-        except HTTPResponseError as e:
-            LOGGER.error('Call to Split API failed. Attribute not created.')
-            raise e
-        except Exception as e:
-            LOGGER.exception(e)
-            raise UnknownApiClientError()
+        :param attribute_id: attribute's id
+        :param traffic_type_id: atribute's traffic type id
+        '''
+        return self._http_client.make_request(
+            self._endpoint['delete'],
+            trafficTypeId=traffic_type_id,
+            attributeId=attribute_id
+        )
 
     def delete_by_instance(self, attribute):
         '''
         Delete an attribute
 
         :param attribute: Attribute instance
         '''
-        return self.delete(attribute.id, attribute.traffic_type_id)
-
-    def delete(self, attribute_id, traffic_type_id):
-        '''
-        Delete an attribute by specifying its id and it's traffic type id.
-
-        :param attribute_id: attribute's id
-        :param traffic_type_id: atribute's traffic type id
-        '''
-        try:
-            return self._http_client.make_request(
-                self._endpoint['delete'],
-                trafficTypeId=traffic_type_id,
-                attributeId=attribute_id
-            )
-        except HTTPResponseError as e:
-            LOGGER.error('Call to Split API failed. Attribute not deleted.')
-            raise e
-        except Exception as e:
-            LOGGER.debug(e)
-            raise UnknownApiClientError()
+        data = as_dict(attribute)
+        return self.delete(
+            data.get('id'),
+            data.get('trafficTypeId')
+        )

splitapiclient/microclients/environment_microclient.py

@@ -3,7 +3,6 @@
     UnknownApiClientError
 from splitapiclient.util.logger import LOGGER
 
-
 class EnvironmentMicroClient:
     '''
     '''
@@ -34,14 +33,7 @@ def list(self):
         :returns: list of Environment objects
         :rtype: list(Environment)
         '''
-        try:
-            response = self._http_client.make_request(
-                self._endpoint['all_items']
-            )
-            return [Environment(item, self._http_client) for item in response]
-        except HTTPResponseError as e:
-            LOGGER.error('Error retrieving items')
-            raise e
-        except Exception as e:
-            LOGGER.debug(e)
-            raise UnknownApiClientError()
+        response = self._http_client.make_request(
+            self._endpoint['all_items']
+        )
+        return [Environment(item, self._http_client) for item in response]

splitapiclient/microclients/identity_microclient.py

@@ -2,6 +2,8 @@
 from splitapiclient.util.exceptions import HTTPResponseError, \
     UnknownApiClientError
 from splitapiclient.util.logger import LOGGER
+from splitapiclient.util.helpers import as_dict
+from splitapiclient.util.bulk_result import BulkOperationResult
 
 
 class IdentityMicroClient:
@@ -86,22 +88,14 @@ def save(self, identity):
         :returns: newly created Identity
         :rtype: Identity
         '''
-        try:
-            data = identity.to_dict() if isinstance(identity, Identity) else identity
-            response = self._http_client.make_request(
-                self._endpoint['create'],
-                data,
-                key=data.get('key'),
-                trafficTypeId=data.get('trafficTypeId'),
-                environmentId=data.get('environmentId'),
-            )
-        except HTTPResponseError as e:
-            LOGGER.error('Call to Split API failed. Identity not created.')
-            raise e
-        except Exception as e:
-            LOGGER.debug(e)
-            raise UnknownApiClientError()
-
+        data = as_dict(identity)
+        response = self._http_client.make_request(
+            self._endpoint['create'],
+            data,
+            key=data.get('key'),
+            trafficTypeId=data.get('trafficTypeId'),
+            environmentId=data.get('environmentId'),
+        )
         return Identity(response, self._http_client)
 
     def save_all(self, identities):
@@ -116,42 +110,29 @@ def save_all(self, identities):
             for the failed item togegther with a status code and a message
         :rtype: tuple
         '''
-        # TODO: Validate!
-        try:
-            # convert Identity objects to dict if necessary
-            to_save = [
-                i.to_dict() if isinstance(i, Identity) else i
-                for i in identities
-            ]
-            response = self._http_client.make_request(
-                self._endpoint['create_many'],
-                to_save,
-                trafficTypeId=to_save[0]['trafficTypeId'],
-                environmentId=to_save[0]['environmentId']
-            )
-
-            successful = [
-                Identity(i, self._http_client)
-                for i in response['objects']
-            ]
-
-            failed = [
-                {
-                    'object': Identity(i['object'], self._http_client),
-                    'status': i['status'],
-                    'message': i['message'],
-                }
-                for i in response['failed']
-            ]
-
-            return successful, failed
-
-        except HTTPResponseError as e:
-            LOGGER.error('Call to Split API failed. Identities not created.')
-            raise e
-        except Exception as e:
-            LOGGER.debug(e)
-            raise UnknownApiClientError()
+        to_save = [as_dict(i) for i in identities]
+        response = self._http_client.make_request(
+            self._endpoint['create_many'],
+            to_save,
+            trafficTypeId=to_save[0].get('trafficTypeId'),
+            environmentId=to_save[0].get('environmentId')
+        )
+
+        successful = [
+            Identity(i, self._http_client)
+            for i in response.get('objects', [])
+        ]
+
+        failed = [
+            {
+                'object': Identity(i['object'], self._http_client),
+                'status': i['status'],
+                'message': i['message'],
+            }
+            for i in response.get('failed', [])
+        ]
+
+        return BulkOperationResult(successful, failed, response.get('metadata'))
 
     def update(self, identity):
         '''
@@ -163,22 +144,14 @@ def update(self, identity):
         :returns: updated Identity
         :rtype: Identity
         '''
-        try:
-            data = identity.to_dict() if isinstance(identity, Identity) else identity
-            response = self._http_client.make_request(
-                self._endpoint['update'],
-                data,
-                key=data.get('key'),
-                trafficTypeId=data.get('trafficTypeId'),
-                environmentId=data.get('environmentId'),
-            )
-        except HTTPResponseError as e:
-            LOGGER.error('Call to Split API failed. Identity not created.')
-            raise e
-        except Exception as e:
-            LOGGER.debug(e)
-            raise UnknownApiClientError()
-
+        data = as_dict(identity)
+        response = self._http_client.make_request(
+            self._endpoint['update'],
+            data,
+            key=data.get('key'),
+            trafficTypeId=data.get('trafficTypeId'),
+            environmentId=data.get('environmentId'),
+        )
         return Identity(response, self._http_client)
 
     def patch(self, identity):
@@ -191,35 +164,15 @@ def patch(self, identity):
         :returns: patched Identity
         :rtype: Identity
         '''
-        try:
-            data = identity.to_dict() if isinstance(identity, Identity) else identity
-            response = self._http_client.make_request(
-                self._endpoint['patch'],
-                data,
-                key=data.get('key'),
-                trafficTypeId=data.get('trafficTypeId'),
-                environmentId=data.get('environmentId'),
-            )
-        except HTTPResponseError as e:
-            LOGGER.error('Call to Split API failed. Identity not created.')
-            raise e
-        except Exception as e:
-            LOGGER.debug(e)
-            raise UnknownApiClientError()
-
-        return Identity(response, self._http_client)
-
-    def delete_by_instance(self, identity):
-        '''
-        Delete the identity
-
-        :param identity: Identity instance
-        '''
-        return self.delete(
-            identity.traffic_type_id,
-            identity.environment_id,
-            identity.key
+        data = as_dict(identity)
+        response = self._http_client.make_request(
+            self._endpoint['patch'],
+            data,
+            key=data.get('key'),
+            trafficTypeId=data.get('trafficTypeId'),
+            environmentId=data.get('environmentId'),
         )
+        return Identity(response, self._http_client)
 
     def delete(self, traffic_type_id, environment_id, key):
         '''
@@ -230,16 +183,22 @@ def delete(self, traffic_type_id, environment_id, key):
         :param environment_id: Identity's environment id
         :param key: Identity's key
         '''
-        try:
-            self._http_client.make_request(
-                self._endpoint['delete_attributes'],
-                key=key,
-                trafficTypeId=traffic_type_id,
-                environmentId=environment_id
-            )
-        except HTTPResponseError as e:
-            LOGGER.error('Call to Split API failed. Identity not patched.')
-            raise e
-        except Exception as e:
-            LOGGER.debug(e)
-            raise UnknownApiClientError()
+        self._http_client.make_request(
+            self._endpoint['delete_attributes'],
+            key=key,
+            trafficTypeId=traffic_type_id,
+            environmentId=environment_id
+        )
+
+    def delete_by_instance(self, identity):
+        '''
+        Delete the identity
+
+        :param identity: Identity instance
+        '''
+        data = as_dict(identity)
+        return self.delete(
+            data.get('trafficTypeId'),
+            data.get('environmentId'),
+            data.get('key')
+        )

splitapiclient/microclients/traffic_type_microclient.py

@@ -34,14 +34,7 @@ def list(self):
         :returns: List of TrafficType objects
         :rtype: list(TrafficType)
         '''
-        try:
-            response = self._http_client.make_request(
-                self._endpoint['all_items']
-            )
-            return [TrafficType(item, self._http_client) for item in response]
-        except HTTPResponseError as e:
-            LOGGER.error('Error retrieving items')
-            raise e
-        except Exception as e:
-            LOGGER.debug(e)
-            raise UnknownApiClientError()
+        response = self._http_client.make_request(
+            self._endpoint['all_items']
+        )
+        return [TrafficType(item, self._http_client) for item in response]