incognia-python 2.0.0__tar.gz → 2.1.0__tar.gz

{incognia_python-2.0.0 → incognia_python-2.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: incognia-python
-Version: 2.0.0
+Version: 2.1.0
 Summary: Python lightweight client library for Incognia APIs
 Home-page: https://github.com/inloco/incognia-python
 Author: Incognia

{incognia_python-2.0.0 → incognia_python-2.1.0}/incognia/api.py

@@ -1,7 +1,7 @@
 import datetime as dt
 from typing import Optional, List
 
-from .datetime_util import total_milliseconds_since_epoch
+from .datetime_util import total_milliseconds_since_epoch, has_timezone
 from .endpoints import Endpoints
 from .exceptions import IncogniaHTTPError, IncogniaError
 from .json_util import encode
@@ -50,33 +50,46 @@ class IncogniaAPI:
 
     def register_feedback(self,
                           event: str,
-                          timestamp: dt.datetime,
+                          timestamp: dt.datetime = None,
                           external_id: Optional[str] = None,
                           login_id: Optional[str] = None,
                           payment_id: Optional[str] = None,
                           signup_id: Optional[str] = None,
                           account_id: Optional[str] = None,
                           installation_id: Optional[str] = None,
-                          session_token: Optional[str] = None) -> None:
+                          session_token: Optional[str] = None,
+                          request_token: Optional[str] = None,
+                          occurred_at: dt.datetime = None,
+                          expires_at: dt.datetime = None) -> None:
         if not event:
             raise IncogniaError('event is required.')
-        if not timestamp:
-            raise IncogniaError('timestamp is required.')
+        if timestamp is not None and not has_timezone(timestamp):
+            raise IncogniaError('timestamp must have timezone')
+        if occurred_at is not None and not has_timezone(occurred_at):
+            raise IncogniaError('occurred_at must have timezone')
+        if expires_at is not None and not has_timezone(expires_at):
+            raise IncogniaError('expires_at must have timezone')
 
         try:
             headers = self.__get_authorization_header()
             headers.update(JSON_CONTENT_HEADER)
             body = {
                 'event': event,
-                'timestamp': total_milliseconds_since_epoch(timestamp),
                 'external_id': external_id,
                 'login_id': login_id,
                 'payment_id': payment_id,
                 'signup_id': signup_id,
                 'account_id': account_id,
                 'installation_id': installation_id,
-                'session_token': session_token
+                'session_token': session_token,
+                'request_token': request_token
             }
+            if timestamp is not None:
+                body['timestamp'] = total_milliseconds_since_epoch(timestamp)
+            if occurred_at is not None:
+                body['occurred_at'] = occurred_at.isoformat()
+            if expires_at is not None:
+                body['expires_at'] = expires_at.isoformat()
             data = encode(body)
             return self.__request.post(Endpoints.FEEDBACKS, headers=headers, data=data)
 

incognia_python-2.1.0/incognia/datetime_util.py

@@ -0,0 +1,9 @@
+import datetime as dt
+
+
+def total_milliseconds_since_epoch(t: dt.datetime) -> int:
+    return int((t - dt.datetime.fromtimestamp(0, dt.timezone.utc)).total_seconds() * 1000.0)
+
+
+def has_timezone(d: dt.datetime) -> bool:
+    return d.tzinfo is not None and d.tzinfo.utcoffset(d) is not None

{incognia_python-2.0.0 → incognia_python-2.1.0}/incognia_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: incognia-python
-Version: 2.0.0
+Version: 2.1.0
 Summary: Python lightweight client library for Incognia APIs
 Home-page: https://github.com/inloco/incognia-python
 Author: Incognia

incognia_python-2.1.0/requirements.txt

@@ -0,0 +1,2 @@
+requests~=2.32.3
+setuptools~=71.1.0

{incognia_python-2.0.0 → incognia_python-2.1.0}/tests/test_api.py

@@ -16,6 +16,7 @@ class TestIncogniaAPI(TestCase):
     CLIENT_SECRET: Final[str] = 'ANY_SECRET'
     INSTALLATION_ID: Final[str] = 'ANY_INSTALLATION_ID'
     SESSION_TOKEN: Final[str] = 'ANY_SESSION_TOKEN'
+    REQUEST_TOKEN: Final[str] = 'ANY_REQUEST_TOKEN'
     INVALID_INSTALLATION_ID: Final[str] = 'INVALID_INSTALLATION_ID'
     INVALID_SESSION_TOKEN: Final[str] = 'INVALID_SESSION_TOKEN'
     ACCOUNT_ID: Final[str] = 'ANY_ACCOUNT_ID'
@@ -71,14 +72,30 @@ class TestIncogniaAPI(TestCase):
     CLIENT_ERROR_CODE: Final[int] = 400
     VALID_EVENT_FEEDBACK_TYPE: Final[str] = 'valid_event_feedback_type'
     INVALID_EVENT_FEEDBACK_TYPE: Final[str] = 'invalid_event_feedback_type'
-    TIMESTAMP: Final[dt.datetime] = dt.datetime.utcfromtimestamp(0)
+    TIMESTAMP: Final[dt.datetime] = dt.datetime.now(dt.timezone.utc)
+    TIMESTAMP_WITHOUT_TIMEZONE: Final[dt.datetime] = dt.datetime.now()
+    LOGIN_ID: Final[str] = 'ANY_LOGIN_ID'
+    PAYMENT_ID: Final[str] = 'ANY_PAYMENT_ID'
     REGISTER_VALID_FEEDBACK_DATA: Final[bytes] = encode({
+        'event': f'{VALID_EVENT_FEEDBACK_TYPE}'
+    })
+    REGISTER_VALID_FEEDBACK_DATA_FULL: Final[bytes] = encode({
         'event': f'{VALID_EVENT_FEEDBACK_TYPE}',
-        'timestamp': 0
+        'external_id': f'{EXTERNAL_ID}',
+        'login_id': f'{LOGIN_ID}',
+        'payment_id': f'{PAYMENT_ID}',
+        'signup_id': f'{SIGNUP_ID}',
+        'account_id': f'{ACCOUNT_ID}',
+        'installation_id': f'{INSTALLATION_ID}',
+        'session_token': f'{SESSION_TOKEN}',
+        'request_token': f'{REQUEST_TOKEN}',
+        'timestamp': int((
+            TIMESTAMP - dt.datetime.fromtimestamp(0, dt.timezone.utc)).total_seconds() * 1000.0),
+        'occurred_at': TIMESTAMP.isoformat(),
+        'expires_at': TIMESTAMP.isoformat(),
     })
     REGISTER_INVALID_FEEDBACK_DATA: Final[bytes] = encode({
-        'event': f'{INVALID_EVENT_FEEDBACK_TYPE}',
-        'timestamp': 0
+        'event': f'{INVALID_EVENT_FEEDBACK_TYPE}'
     })
     REGISTER_VALID_PAYMENT_DATA: Final[bytes] = encode({
         'type': 'payment',
@@ -185,32 +202,86 @@ class TestIncogniaAPI(TestCase):
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        api.register_feedback(self.VALID_EVENT_FEEDBACK_TYPE, self.TIMESTAMP)
+        api.register_feedback(self.VALID_EVENT_FEEDBACK_TYPE)
 
         mock_token_manager_get.assert_called()
         mock_base_request_post.assert_called_with(Endpoints.FEEDBACKS,
                                                   headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
                                                   data=self.REGISTER_VALID_FEEDBACK_DATA)
 
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_feedback_when_all_fields_are_valid_should_work(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        api.register_feedback(self.VALID_EVENT_FEEDBACK_TYPE,
+                              timestamp=self.TIMESTAMP,
+                              occurred_at=self.TIMESTAMP,
+                              expires_at=self.TIMESTAMP,
+                              external_id=self.EXTERNAL_ID,
+                              login_id=self.LOGIN_ID,
+                              payment_id=self.PAYMENT_ID,
+                              signup_id=self.SIGNUP_ID,
+                              account_id=self.ACCOUNT_ID,
+                              installation_id=self.INSTALLATION_ID,
+                              session_token=self.SESSION_TOKEN,
+                              request_token=self.REQUEST_TOKEN)
+
+        mock_token_manager_get.assert_called()
+        mock_base_request_post.assert_called_with(Endpoints.FEEDBACKS,
+                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
+                                                  data=self.REGISTER_VALID_FEEDBACK_DATA_FULL)
+
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
     def test_register_feedback_when_event_is_empty_should_raise_an_IncogniaError(
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        self.assertRaises(IncogniaError, api.register_feedback, event='', timestamp=self.TIMESTAMP)
+        self.assertRaises(IncogniaError, api.register_feedback, event='')
+
+        mock_token_manager_get.assert_not_called()
+        mock_base_request_post.assert_not_called()
+
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_feedback_when_timestamp_does_not_have_timezone_should_raise_IncogniaError(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        self.assertRaises(IncogniaError,
+                          api.register_feedback,
+                          event=self.VALID_EVENT_FEEDBACK_TYPE,
+                          timestamp=self.TIMESTAMP_WITHOUT_TIMEZONE)
+
+        mock_token_manager_get.assert_not_called()
+        mock_base_request_post.assert_not_called()
+
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_feedback_when_occurred_at_does_not_have_timezone_should_raise_IncogniaError(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        self.assertRaises(IncogniaError,
+                          api.register_feedback,
+                          event=self.VALID_EVENT_FEEDBACK_TYPE,
+                          occurred_at=self.TIMESTAMP_WITHOUT_TIMEZONE)
 
         mock_token_manager_get.assert_not_called()
         mock_base_request_post.assert_not_called()
 
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
-    def test_register_feedback_when_timestamp_is_none_should_raise_an_IncogniaError(
+    def test_register_feedback_when_expires_at_does_not_have_timezone_should_raise_IncogniaError(
             self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
-        self.assertRaises(IncogniaError, api.register_feedback,
-                          event=self.VALID_EVENT_FEEDBACK_TYPE, timestamp=None)
+        self.assertRaises(IncogniaError,
+                          api.register_feedback,
+                          event=self.VALID_EVENT_FEEDBACK_TYPE,
+                          expires_at=self.TIMESTAMP_WITHOUT_TIMEZONE)
 
         mock_token_manager_get.assert_not_called()
         mock_base_request_post.assert_not_called()
@@ -224,8 +295,7 @@ class TestIncogniaAPI(TestCase):
         api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
 
         self.assertRaises(IncogniaHTTPError, api.register_feedback,
-                          event=self.INVALID_EVENT_FEEDBACK_TYPE,
-                          timestamp=self.TIMESTAMP)
+                          event=self.INVALID_EVENT_FEEDBACK_TYPE)
 
         mock_token_manager_get.assert_called()
         mock_base_request_post.assert_called_with(Endpoints.FEEDBACKS,

incognia_python-2.0.0/incognia/datetime_util.py

@@ -1,5 +0,0 @@
-import datetime as dt
-
-
-def total_milliseconds_since_epoch(t: dt.datetime) -> int:
-    return int((t - dt.datetime.utcfromtimestamp(0)).total_seconds() * 1000.0)

incognia_python-2.0.0/requirements.txt

@@ -1,2 +0,0 @@
-requests~=2.32.3
-setuptools~=70.2.0