fix attribute property names. add unit tests for camelcase and more end to end

Author: mredolatti

identify/main/identify_sync_client.py

@@ -66,17 +66,17 @@ def create_attribute_for_traffic_type(self, traffic_type_id, attr_data):
         :param attr_data: Dictionary with the the data to create the new
             attribute. Should include the followind fields:
                 - 'id': Id of the new attribute
-                - 'display_name': Display Name of the new attribute
+                - 'displayName': Display Name of the new attribute
                 - 'description': Description of the new attribute
-                - 'data_type': Data type of the new attribute
+                - 'dataType': Data type of the new attribute
         '''
         return Attribute.create(
             self._client,
             attr_data.get('id'),
             traffic_type_id,
-            attr_data.get('display_name'),
+            attr_data.get('displayName'),
             attr_data.get('description'),
-            attr_data.get('data_type')
+            attr_data.get('dataType')
         )
 
     def delete_attribute_from_schema(self, traffic_type_id, attribute_id):

identify/resources/attribute.py

@@ -94,25 +94,14 @@ def _build_single_from_collection_response(cls, client, response):
             response['dataType']
         )
 
-    def to_dict(self):
-        temp = {
-            'id': self.id,
-            'trafficTypeId': self.traffic_type_id,
-            'displayName': self.display_name,
-            'description': self.description,
-            'dataType': self.data_type
-        }
-
-        return temp
-
     @classmethod
     def create(cls, client, id, traffic_type_id, display_name, description,
                data_type):
         '''
         '''
         # TODO: Validate!
         try:
-            client.make_request(
+            response = client.make_request(
                 cls._endpoint['create'],
                 {
                     'id': id,
@@ -123,6 +112,16 @@ def create(cls, client, id, traffic_type_id, display_name, description,
                 },
                 trafficTypeId=traffic_type_id
             )
+
+            return Attribute(
+                client,
+                response['id'],
+                response['trafficTypeId'],
+                response['displayName'],
+                response['description'],
+                response['dataType']
+            )
+
         except HTTPResponseError as e:
             LOGGER.error('Call to Identify API failed. Attribute not created.')
             raise e

identify/resources/base_resource.py

@@ -113,13 +113,15 @@ def _validate(cls, response_item):
 
     def to_dict(self):
         '''
+        Returns a dictionary with the property names in camelCase, in compliance
+        with the Identify backend
         '''
         try:
             temp = {
                 attribute: getattr(
                     self, '_' + camelcase.to_underscore(attribute),
-                    None)
-                for attribute in self._schema
+                    None
+                ) for attribute in self._schema
             }
             return temp
         except Exception as e:

identify/resources/identity.py

@@ -148,7 +148,7 @@ def create_many(cls, client, traffic_type_id, environment_id, entities):
         '''
         # TODO: Validate!
         try:
-            client.make_request(
+            response = client.make_request(
                 cls._endpoint['create_many'],
                 [
                     {
@@ -162,6 +162,13 @@ def create_many(cls, client, traffic_type_id, environment_id, entities):
                 trafficTypeId=traffic_type_id,
                 environmentId=environment_id
             )
+            return [
+                Identity(
+                    client, i['key'], i['trafficTypeId'],
+                    i['environmentId'], i['values']
+                ) for i in response
+            ]
+
         except HTTPResponseError as e:
             LOGGER.error('Call to Identify API failed. Identities not created.')
             raise e

identify/resources/traffic_type.py

@@ -28,12 +28,12 @@ class TrafficType(BaseResource):
         'displayAttributeId': 'string'
     }
 
-    def __init__(self, client, id, name=None, display_name=None):
+    def __init__(self, client, id, name=None, display_attribute_id=None):
         '''
         '''
         BaseResource.__init__(self, client, id)
         self._name = name
-        self._display_name = display_name
+        self._display_attribute_id = display_attribute_id
 
     @property
     def id(self):
@@ -44,22 +44,22 @@ def name(self):
         return self._name
 
     @property
-    def display_name(self):
-        return self._display_name
+    def display_attribute_id(self):
+        return self._display_attribute_id
 
     def fetch_attributes(self):
         '''
         '''
         return Attribute.retrieve_all(self._client, trafficTypeId=self._id)
 
-    def add_attribute(self, id, display_name, description, data_type):
+    def add_attribute(self, id, display_attribute_id, description, data_type):
         '''
         '''
         return Attribute.create(
             self._client,
             id,
             self._id,
-            display_name,
+            display_attribute_id,
             description,
             data_type
         )

identify/tests/e2e/e2etests.py

@@ -3,6 +3,10 @@
 import os
 import os.path
 from identify.main import get_client
+from identify.resources.traffic_type import TrafficType
+from identify.resources.environment import Environment
+from identify.resources.attribute import Attribute
+from identify.resources.identity import Identity
 
 
 class TestEndToEnd:
@@ -16,12 +20,10 @@ def setup_class(cls):
         cls.mock_server_subprocess = subprocess.Popen(
             ['python', os.path.join(dir_path, 'server.py')]
         )
-        time.sleep(5)
+        time.sleep(3)
 
-    def test_successful_command_sequence(self):
+    def test_traffic_type_endpoint(self):
         '''
-        Test a basic command sequence using the get_client entry point function,
-        issuing calls to a mocked API running in background.
         '''
         c = get_client({
             'base_url': 'http://localhost:8888',
@@ -30,39 +32,112 @@ def test_successful_command_sequence(self):
 
         tts = c.get_traffic_types()
         assert isinstance(tts, list)
+        assert all(isinstance(tt, TrafficType) for tt in tts)
+        assert all(
+            {
+                'id': tt.id,
+                'name': tt.name,
+                'displayAttributeId': tt.display_attribute_id
+            } == tt.to_dict()
+            for tt in tts
+        )
+
+    def test_environments_endpoint(self):
+        '''
+        '''
+        c = get_client({
+            'base_url': 'http://localhost:8888',
+            'apikey': 'Admin'
+        })
 
         envs = c.get_environments()
         assert isinstance(envs, list)
+        assert all(isinstance(env, Environment) for env in envs)
+        assert all(
+            {
+                'id': env.id,
+                'name': env.name,
+            } == env.to_dict()
+            for env in envs
+        )
 
-        attrs = c.get_attributes_for_traffic_type(tts[0].id)
+    def test_attribute_endpoints(self):
+        '''
+        '''
+        c = get_client({
+            'base_url': 'http://localhost:8888',
+            'apikey': 'Admin'
+        })
+
+        attrs = c.get_attributes_for_traffic_type('1')
         assert isinstance(attrs, list)
+        assert all(isinstance(attr, Attribute) for attr in attrs)
+        assert all(
+            {
+                'id': attr.id,
+                'trafficTypeId': attr.traffic_type_id,
+                'displayName': attr.display_name,
+                'description': attr.description,
+                'dataType': attr.data_type,
+            } == attr.to_dict()
+            for attr in attrs
+        )
 
+        new_attr_props = {
+            'id': 'aa',
+            'trafficTypeId': '1',
+            'displayName': 'AA',
+            'description': 'DESC',
+            'dataType': 'STRING'
+        }
         new_attr = c.create_attribute_for_traffic_type(
-            1,
+            '1',
             {
                 'id': 'aa',
-                'display_name': 'AA',
+                'displayName': 'AA',
                 'description': 'DESC',
-                'data_type': 'STRING'
+                'dataType': 'STRING'
             }
         )
-        assert isinstance(new_attr, object)
+        assert new_attr_props == new_attr.to_dict()
 
-        attrs_2 = c.get_attributes_for_traffic_type(tts[0].id)
-        assert isinstance(attrs_2, list)
+        res_delete = c.delete_attribute_from_schema(1, 'aa')
+        assert res_delete is None
 
-        c.delete_attribute_from_schema(1, 'aa')
-        attrs_3 = c.get_attributes_for_traffic_type(tts[0].id)
-        assert isinstance(attrs_3, list)
+    def test_identity_endpoints(self):
+        '''
+        '''
+        c = get_client({
+            'base_url': 'http://localhost:8888',
+            'apikey': 'Admin'
+        })
 
         i1 = c.add_identity('1',  '1', 'keycita', {'a1': 'qwe'})
-        assert isinstance(i1, object)
+        assert isinstance(i1, Identity)
+        assert {
+            'key': i1.key,
+            'environmentId': i1.environment_id,
+            'trafficTypeId': i1.traffic_type_id,
+            'values': i1.values
+        } == i1.to_dict()
 
         i2 = c.update_identity('1',  '1', 'keycita', {'a1': 'qwe2'})
-        assert isinstance(i2, object)
+        assert isinstance(i2, Identity)
+        assert {
+            'key': i2.key,
+            'environmentId': i2.environment_id,
+            'trafficTypeId': i2.traffic_type_id,
+            'values': i2.values
+        } == i2.to_dict()
 
         i3 = c.patch_identity('1',  '1', 'keycita', {'a1': 'qwe3'})
-        assert isinstance(i3, object)
+        assert isinstance(i3, Identity)
+        assert {
+            'key': i3.key,
+            'environmentId': i3.environment_id,
+            'trafficTypeId': i3.traffic_type_id,
+            'values': i3.values
+        } == i3.to_dict()
 
         res_add_identities = c.add_identities(
             '1',
@@ -73,6 +148,8 @@ def test_successful_command_sequence(self):
             }
         )
         assert res_add_identities is None
+        assert isinstance(res_add_identities, list)
+        assert all(isinstance(i, Identity) for i in res_add_identities)
 
         res_delete_attr = c.delete_attributes_from_key('1',  '1', 'keycita')
         assert res_delete_attr is None

identify/tests/util/__init__.py

@@ -0,0 +1,76 @@
+from __future__ import absolute_import, division, print_function, \
+    unicode_literals
+
+from identify.util.camelcase import to_underscore, from_underscore
+
+
+class TestCamelCaseUtils:
+    '''
+    Tests for the camelcase module utilities
+    '''
+
+    def test_to_underscore(self):
+        '''
+        Test that camelcase names are correctly converted to underscores.
+        '''
+        cases = [{
+            'in': 'camelCase',
+            'out': 'camel_case',
+        }, {
+            'in': 'camelcase',
+            'out': 'camelcase',
+        }, {
+            'in': 'CamelCase',
+            'out': 'camel_case',
+        }, {
+            'in': 'camelCCase',
+            'out': 'camel_c_case',
+        }, {
+            'in': '',
+            'out': '',
+        }, {
+            'in': 'camel3Case',
+            'out': 'camel3_case',
+        }, {
+            'in': 'camelCaseMultipleWords',
+            'out': 'camel_case_multiple_words',
+        }, {
+            'in': 'camelCase_Underscore',
+            'out': 'camel_case__underscore',
+        }]
+
+        for case in cases:
+            assert to_underscore(case['in']) == case['out']
+
+    def test_from_underscore(self):
+        '''
+        Test that camelcase names are correctly converted to underscores.
+        '''
+        cases = [{
+            'out': 'camelCase',
+            'in': 'camel_case',
+        }, {
+            'out': 'camelcase',
+            'in': 'camelcase',
+        }, {
+            'out': 'camelCase',
+            'in': 'camel_case',
+        }, {
+            'out': 'camelCCase',
+            'in': 'camel_c_case',
+        }, {
+            'out': '',
+            'in': '',
+        }, {
+            'out': 'camel3Case',
+            'in': 'camel3_case',
+        }, {
+            'out': 'camelCaseMultipleWords',
+            'in': 'camel_case_multiple_words',
+        }, {
+            'out': 'camelCase_Underscore',
+            'in': 'camel_case__underscore',
+        }]
+
+        for case in cases:
+            assert from_underscore(case['in']) == case['out']