incognia-python 3.0.0__tar.gz → 3.2.0__tar.gz

{incognia_python-3.0.0 → incognia_python-3.2.0}/CODEOWNERS

@@ -2,4 +2,4 @@
 # the repo. Unless a later match takes precedence,
 # @inloco/incognia-owners will be requested for
 # review when someone opens a pull request.
-*       @inloco/incognia-owners
+*       @inloco/api-codeowners

{incognia_python-3.0.0 → incognia_python-3.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: incognia-python
-Version: 3.0.0
+Version: 3.2.0
 Summary: Python lightweight client library for Incognia APIs
 Home-page: https://github.com/inloco/incognia-python
 Author: Incognia
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: requests
+Dynamic: license-file
 
 # Incognia API Python Client 🐍
 

{incognia_python-3.0.0 → incognia_python-3.2.0}/incognia/api.py

@@ -1,11 +1,20 @@
 import datetime as dt
 from typing import Optional, List
 
-from .datetime_util import has_timezone
+from .datetime_util import has_timezone, datetime_valid
 from .endpoints import Endpoints
 from .exceptions import IncogniaHTTPError, IncogniaError
 from .json_util import encode
-from .models import Coordinates, StructuredAddress, TransactionAddress, PaymentValue, PaymentMethod
+from .models import (
+    Coordinates,
+    StructuredAddress,
+    TransactionAddress,
+    PaymentValue,
+    PaymentMethod,
+    Location,
+    Coupon,
+    PersonID,
+)
 from .singleton import Singleton
 from .token_manager import TokenManager
 from .base_request import BaseRequest, JSON_CONTENT_HEADER
@@ -27,7 +36,11 @@ class IncogniaAPI(metaclass=Singleton):
                             address_coordinates: Optional[Coordinates] = None,
                             external_id: Optional[str] = None,
                             policy_id: Optional[str] = None,
-                            account_id: Optional[str] = None) -> dict:
+                            account_id: Optional[str] = None,
+                            device_os: Optional[str] = None,
+                            app_version: Optional[str] = None,
+                            person_id: Optional[PersonID] = None,
+                            custom_properties: Optional[dict] = None) -> dict:
         if not request_token:
             raise IncogniaError('request_token is required.')
 
@@ -41,7 +54,36 @@ class IncogniaAPI(metaclass=Singleton):
                 'address_coordinates': address_coordinates,
                 'external_id': external_id,
                 'policy_id': policy_id,
-                'account_id': account_id
+                'account_id': account_id,
+                'device_os': device_os.lower() if device_os is not None else None,
+                'app_version': app_version,
+                'person_id': person_id,
+                'custom_properties': custom_properties
+            }
+            data = encode(body)
+            return self.__request.post(Endpoints.SIGNUPS, headers=headers, data=data)
+
+        except IncogniaHTTPError as e:
+            raise IncogniaHTTPError(e) from None
+
+    def register_new_web_signup(self,
+                                request_token: Optional[str],
+                                policy_id: Optional[str] = None,
+                                account_id: Optional[str] = None,
+                                custom_properties: Optional[dict] = None,
+                                person_id: Optional[PersonID] = None) -> dict:
+        if not request_token:
+            raise IncogniaError('request_token is required.')
+
+        try:
+            headers = self.__get_authorization_header()
+            headers.update(JSON_CONTENT_HEADER)
+            body = {
+                'request_token': request_token,
+                'policy_id': policy_id,
+                'account_id': account_id,
+                'custom_properties': custom_properties,
+                'person_id': person_id,
             }
             data = encode(body)
             return self.__request.post(Endpoints.SIGNUPS, headers=headers, data=data)
@@ -59,7 +101,8 @@ class IncogniaAPI(metaclass=Singleton):
                           installation_id: Optional[str] = None,
                           request_token: Optional[str] = None,
                           occurred_at: dt.datetime = None,
-                          expires_at: dt.datetime = None) -> None:
+                          expires_at: dt.datetime = None,
+                          person_id: Optional[PersonID] = None) -> None:
         if not event:
             raise IncogniaError('event is required.')
         if occurred_at is not None and not has_timezone(occurred_at):
@@ -78,7 +121,8 @@ class IncogniaAPI(metaclass=Singleton):
                 'signup_id': signup_id,
                 'account_id': account_id,
                 'installation_id': installation_id,
-                'request_token': request_token
+                'request_token': request_token,
+                'person_id': person_id,
             }
             if occurred_at is not None:
                 body['occurred_at'] = occurred_at.isoformat()
@@ -94,15 +138,32 @@ class IncogniaAPI(metaclass=Singleton):
                          request_token: str,
                          account_id: str,
                          external_id: Optional[str] = None,
+                         location: Optional[Location] = None,
                          addresses: Optional[List[TransactionAddress]] = None,
                          payment_value: Optional[PaymentValue] = None,
                          payment_methods: Optional[List[PaymentMethod]] = None,
                          evaluate: Optional[bool] = None,
-                         policy_id: Optional[str] = None) -> dict:
+                         policy_id: Optional[str] = None,
+                         custom_properties: Optional[dict] = None,
+                         coupon: Optional[Coupon] = None,
+                         device_os: Optional[str] = None,
+                         app_version: Optional[str] = None,
+                         store_id: Optional[str] = None,
+                         person_id: Optional[PersonID] = None) -> dict:
         if not request_token:
             raise IncogniaError('request_token is required.')
         if not account_id:
             raise IncogniaError('account_id is required.')
+        if location is not None:
+            if location['latitude'] is None:
+                raise IncogniaError('location argument requires "latitude" field')
+            if location['longitude'] is None:
+                raise IncogniaError('location argument requires "longitude" field')
+            if (
+                location['collected_at'] is not None
+                and not datetime_valid(location['collected_at'])
+            ):
+                raise IncogniaError('location["collected_at"] must conform to ISO-8601 format')
 
         try:
             headers = self.__get_authorization_header()
@@ -113,10 +174,17 @@ class IncogniaAPI(metaclass=Singleton):
                 'request_token': request_token,
                 'account_id': account_id,
                 'external_id': external_id,
+                'location': location,
                 'addresses': addresses,
                 'payment_value': payment_value,
                 'payment_methods': payment_methods,
-                'policy_id': policy_id
+                'policy_id': policy_id,
+                'custom_properties': custom_properties,
+                'coupon': coupon,
+                'device_os': device_os.lower() if device_os is not None else None,
+                'app_version': app_version,
+                'store_id': store_id,
+                'person_id': person_id,
             }
             data = encode(body)
             return self.__request.post(Endpoints.TRANSACTIONS, headers=headers, params=params,
@@ -128,13 +196,27 @@ class IncogniaAPI(metaclass=Singleton):
     def register_login(self,
                        request_token: str,
                        account_id: str,
+                       location: Optional[Location] = None,
                        external_id: Optional[str] = None,
                        evaluate: Optional[bool] = None,
-                       policy_id: Optional[str] = None) -> dict:
+                       policy_id: Optional[str] = None,
+                       device_os: Optional[str] = None,
+                       app_version: Optional[str] = None,
+                       person_id: Optional[PersonID] = None) -> dict:
         if not request_token:
             raise IncogniaError('request_token is required.')
         if not account_id:
             raise IncogniaError('account_id is required.')
+        if location is not None:
+            if location['latitude'] is None:
+                raise IncogniaError('location argument requires "latitude" field')
+            if location['longitude'] is None:
+                raise IncogniaError('location argument requires "longitude" field')
+            if (
+                location['collected_at'] is not None
+                and not datetime_valid(location['collected_at'])
+            ):
+                raise IncogniaError('location["collected_at"] must conform to ISO-8601 format')
 
         try:
             headers = self.__get_authorization_header()
@@ -144,8 +226,12 @@ class IncogniaAPI(metaclass=Singleton):
                 'type': 'login',
                 'request_token': request_token,
                 'account_id': account_id,
+                'location': location,
                 'external_id': external_id,
-                'policy_id': policy_id
+                'policy_id': policy_id,
+                'device_os': device_os.lower() if device_os is not None else None,
+                'app_version': app_version,
+                'person_id': person_id,
             }
             data = encode(body)
             return self.__request.post(Endpoints.TRANSACTIONS, headers=headers, params=params,
@@ -159,7 +245,9 @@ class IncogniaAPI(metaclass=Singleton):
                            account_id: str,
                            external_id: Optional[str] = None,
                            evaluate: Optional[bool] = None,
-                           policy_id: Optional[str] = None) -> dict:
+                           policy_id: Optional[str] = None,
+                           custom_properties: Optional[dict] = None,
+                           person_id: Optional[PersonID] = None) -> dict:
         if not request_token:
             raise IncogniaError('request_token is required.')
         if not account_id:
@@ -174,7 +262,9 @@ class IncogniaAPI(metaclass=Singleton):
                 'request_token': request_token,
                 'account_id': account_id,
                 'external_id': external_id,
-                'policy_id': policy_id
+                'policy_id': policy_id,
+                'custom_properties': custom_properties,
+                'person_id': person_id,
             }
             data = encode(body)
             return self.__request.post(Endpoints.TRANSACTIONS, headers=headers, params=params,

incognia_python-3.2.0/incognia/datetime_util.py

@@ -0,0 +1,13 @@
+from datetime import datetime
+
+
+def has_timezone(d: datetime) -> bool:
+    return d.tzinfo is not None and d.tzinfo.utcoffset(d) is not None
+
+
+def datetime_valid(dt_str):
+    try:
+        datetime.fromisoformat(dt_str.replace('Z', '+00:00'))
+    except ValueError:
+        return False
+    return True

{incognia_python-3.0.0 → incognia_python-3.2.0}/incognia/models.py

@@ -20,6 +20,14 @@ class StructuredAddress(TypedDict, total=False):
     postal_code: str
 
 
+class Coupon (TypedDict, total=False):
+    type: Literal['percent_off', 'fixed_value']
+    value: float
+    max_discount: float
+    id: str
+    name: str
+
+
 class TransactionAddress(TypedDict, total=False):
     type: Literal['shipping', 'billing', 'home']
     structured_address: StructuredAddress
@@ -39,6 +47,19 @@ class CardInfo(TypedDict, total=False):
 
 
 class PaymentMethod(TypedDict, total=False):
-    type: Literal['credit', 'debit']
+    type: Literal['account_balance', 'apple_pay', 'bancolombia',
+                  'boleto_bancario', 'cash', 'credit_card', 'debit_card',
+                  'google_pay', 'meal_voucher', 'nu_pay', 'paypal', 'pix']
     credit_card_info: CardInfo
     debit_card_info: CardInfo
+
+
+class Location(TypedDict, total=False):
+    latitude: float
+    longitude: float
+    collected_at: str
+
+
+class PersonID(TypedDict, total=False):
+    type: str
+    value: str

{incognia_python-3.0.0 → incognia_python-3.2.0}/incognia_python.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: incognia-python
-Version: 3.0.0
+Version: 3.2.0
 Summary: Python lightweight client library for Incognia APIs
 Home-page: https://github.com/inloco/incognia-python
 Author: Incognia
@@ -13,6 +13,7 @@ Classifier: Programming Language :: Python :: 3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
 Requires-Dist: requests
+Dynamic: license-file
 
 # Incognia API Python Client 🐍
 

{incognia_python-3.0.0 → incognia_python-3.2.0}/tests/test_api.py

@@ -20,6 +20,12 @@ class TestIncogniaAPI(TestCase):
     ACCOUNT_ID: Final[str] = 'ANY_ACCOUNT_ID'
     INVALID_ACCOUNT_ID: Final[str] = 'INVALID_ACCOUNT_ID'
     ADDRESS_LINE: Final[str] = 'ANY_ADDRESS_LINE'
+    DEVICE_OS: Final[str] = 'ANY_DEVICE_OS'
+    APP_VERSION: Final[str] = 'ANY_APP_VERSION'
+    PERSON_ID: Final[dict] = {
+        'type': 'cpf',
+        'value': '12345678901'
+    }
     STRUCTURED_ADDRESS: Final[dict] = {
         'locale': 'ANY_LOCALE',
         'country_name': 'ANY_COUNTRY_NAME',
@@ -60,6 +66,10 @@ class TestIncogniaAPI(TestCase):
     REGISTER_INVALID_SIGNUP_DATA: Final[bytes] = encode({
         'request_token': f'{INVALID_REQUEST_TOKEN}'
     })
+    CUSTOM_PROPERTIES: Final[dict] = {
+        'float_field': 6.092,
+        'string_field': "the next generation of identity",
+    }
     FULL_REGISTER_SIGNUP_DATA: Final[bytes] = encode({
         'request_token': f'{REQUEST_TOKEN}',
         'address_line': f'{ADDRESS_LINE}',
@@ -67,7 +77,24 @@ class TestIncogniaAPI(TestCase):
         'address_coordinates': ADDRESS_COORDINATES,
         'external_id': f'{EXTERNAL_ID}',
         'policy_id': f'{POLICY_ID}',
-        'account_id': f'{ACCOUNT_ID}'
+        'account_id': f'{ACCOUNT_ID}',
+        'device_os': f'{DEVICE_OS.lower()}',
+        'app_version': f'{APP_VERSION}',
+        'person_id': PERSON_ID,
+        'custom_properties': CUSTOM_PROPERTIES
+    })
+    REGISTER_WEB_SIGNUP_DATA: Final[bytes] = encode({
+        'request_token': f'{REQUEST_TOKEN}'
+    })
+    REGISTER_INVALID_WEB_SIGNUP_DATA: Final[bytes] = encode({
+        'request_token': f'{INVALID_REQUEST_TOKEN}'
+    })
+    FULL_REGISTER_WEB_SIGNUP_DATA: Final[bytes] = encode({
+        'request_token': f'{REQUEST_TOKEN}',
+        'policy_id': f'{POLICY_ID}',
+        'account_id': f'{ACCOUNT_ID}',
+        'custom_properties': CUSTOM_PROPERTIES,
+        'person_id': PERSON_ID
     })
     OK_STATUS_CODE: Final[int] = 200
     CLIENT_ERROR_CODE: Final[int] = 400
@@ -76,6 +103,53 @@ class TestIncogniaAPI(TestCase):
     TIMESTAMP_WITHOUT_TIMEZONE: Final[dt.datetime] = dt.datetime.now()
     LOGIN_ID: Final[str] = 'ANY_LOGIN_ID'
     PAYMENT_ID: Final[str] = 'ANY_PAYMENT_ID'
+    STORE_ID: Final[str] = 'ANY_STORE_ID'
+    COUPON: Final[dict] = {
+        "type": "percent_off",
+        "value": 2.5,
+        "max_discount": 50.0,
+        "id": "COUPON_ID",
+        "name": "COUPON_NAME"
+    }
+    TRANSACTION_ADDRESS: Final[dict] = {
+        "type": "billing",
+        "structured_address": STRUCTURED_ADDRESS,
+        "address_coordinates": ADDRESS_COORDINATES
+    }
+    PAYMENT_VALUE: Final[dict] = {
+        'value': 12.34,
+        'currency': 'BRL'
+    }
+    CARD_INFO: Final[dict] = {
+        'bin': '0000000000',
+        'last_four_digits': '0000',
+        'expiry_year': '2029',
+        'expiry_month': '04'
+    }
+    PAYMENT_METHOD: Final[dict] = {
+        'type': 'credit_card',
+        'credit_card_info': CARD_INFO
+    }
+    LOCATION: Final[dict] = {
+        'latitude': 0.000,
+        'longitude': 89.000,
+        'collected_at': TIMESTAMP.isoformat()
+    }
+    INVALID_LOCATION_EMPTY_LATITUDE: Final[dict] = {
+        'latitude': None,
+        'longitude': 13.123,
+        'collected_at': TIMESTAMP.isoformat()
+    }
+    INVALID_LOCATION_EMPTY_LONGITUDE: Final[dict] = {
+        'latitude': 0.000,
+        'longitude': None,
+        'collected_at': TIMESTAMP.isoformat()
+    }
+    INVALID_LOCATION_WRONG_TIMESTAMP: Final[dict] = {
+        'latitude': 0.000,
+        'longitude': 13.123,
+        'collected_at': "12:04 14/10/2024"
+    }
     REGISTER_VALID_FEEDBACK_DATA: Final[bytes] = encode({
         'event': f'{VALID_EVENT_FEEDBACK_TYPE}'
     })
@@ -88,8 +162,9 @@ class TestIncogniaAPI(TestCase):
         'account_id': f'{ACCOUNT_ID}',
         'installation_id': f'{INSTALLATION_ID}',
         'request_token': f'{REQUEST_TOKEN}',
+        'person_id': PERSON_ID,
         'occurred_at': TIMESTAMP.isoformat(),
-        'expires_at': TIMESTAMP.isoformat(),
+        'expires_at': TIMESTAMP.isoformat()
     })
     REGISTER_VALID_PAYMENT_DATA: Final[bytes] = encode({
         'type': 'payment',
@@ -97,6 +172,30 @@ class TestIncogniaAPI(TestCase):
         'account_id': f'{ACCOUNT_ID}',
         'policy_id': f'{POLICY_ID}',
     })
+    REGISTER_VALID_PAYMENT_DATA_ALL_FIELDS: Final[bytes] = encode({
+        'type': 'payment',
+        'request_token': f'{REQUEST_TOKEN}',
+        'account_id': f'{ACCOUNT_ID}',
+        'external_id': f'{EXTERNAL_ID}',
+        'location': LOCATION,
+        'addresses': [TRANSACTION_ADDRESS],
+        'payment_value': PAYMENT_VALUE,
+        'payment_methods': PAYMENT_METHOD,
+        'policy_id': f'{POLICY_ID}',
+        'custom_properties': CUSTOM_PROPERTIES,
+        'coupon': COUPON,
+        'device_os': f'{DEVICE_OS.lower()}',
+        'app_version': f'{APP_VERSION}',
+        'store_id': f'{STORE_ID}',
+        'person_id': PERSON_ID
+    })
+    REGISTER_VALID_PAYMENT_DATA_WITH_LOCATION: Final[bytes] = encode({
+        'type': 'payment',
+        'request_token': f'{REQUEST_TOKEN}',
+        'account_id': f'{ACCOUNT_ID}',
+        'location': LOCATION,
+        'policy_id': f'{POLICY_ID}',
+    })
     REGISTER_INVALID_PAYMENT_DATA: Final[bytes] = encode({
         'type': 'payment',
         'request_token': f'{INVALID_REQUEST_TOKEN}',
@@ -108,12 +207,39 @@ class TestIncogniaAPI(TestCase):
         'account_id': f'{ACCOUNT_ID}',
         'policy_id': f'{POLICY_ID}'
     })
+    REGISTER_VALID_LOGIN_DATA_WITH_LOCATION: Final[bytes] = encode({
+        'type': 'login',
+        'request_token': f'{REQUEST_TOKEN}',
+        'account_id': f'{ACCOUNT_ID}',
+        'location': LOCATION,
+        'policy_id': f'{POLICY_ID}'
+    })
+    REGISTER_VALID_LOGIN_DATA_ALL_FIELDS: Final[bytes] = encode({
+        'type': 'login',
+        'request_token': f'{REQUEST_TOKEN}',
+        'account_id': f'{ACCOUNT_ID}',
+        'location': LOCATION,
+        'external_id': f'{EXTERNAL_ID}',
+        'policy_id': f'{POLICY_ID}',
+        'device_os': f'{DEVICE_OS.lower()}',
+        'app_version': f'{APP_VERSION}',
+        'person_id': PERSON_ID
+    })
     REGISTER_VALID_WEB_LOGIN_DATA: Final[bytes] = encode({
         'type': 'login',
         'request_token': f'{REQUEST_TOKEN}',
         'account_id': f'{ACCOUNT_ID}',
         'policy_id': f'{POLICY_ID}'
     })
+    REGISTER_VALID_WEB_LOGIN_ALL_FIELDS: Final[bytes] = encode({
+        'type': 'login',
+        'request_token': f'{REQUEST_TOKEN}',
+        'account_id': f'{ACCOUNT_ID}',
+        'external_id': f'{EXTERNAL_ID}',
+        'policy_id': f'{POLICY_ID}',
+        'custom_properties': CUSTOM_PROPERTIES,
+        'person_id': PERSON_ID
+    })
     REGISTER_INVALID_LOGIN_DATA: Final[bytes] = encode({
         'type': 'login',
         'request_token': f'{INVALID_REQUEST_TOKEN}',
@@ -148,6 +274,22 @@ class TestIncogniaAPI(TestCase):
 
         self.assertEqual(response, self.JSON_RESPONSE)
 
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_new_web_signup_when_request_token_is_valid_should_return_a_valid_dict(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+        response = api.register_new_web_signup(request_token=self.REQUEST_TOKEN)
+
+        mock_token_manager_get.assert_called()
+        mock_base_request_post.assert_called_with(Endpoints.SIGNUPS,
+                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
+                                                  data=self.REGISTER_WEB_SIGNUP_DATA)
+
+        self.assertEqual(response, self.JSON_RESPONSE)
+
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
     def test_register_new_signup_when_request_token_is_valid_should_return_full_valid_dict_(
@@ -161,7 +303,11 @@ class TestIncogniaAPI(TestCase):
                                            external_id=self.EXTERNAL_ID,
                                            policy_id=self.POLICY_ID,
                                            account_id=self.ACCOUNT_ID,
-                                           request_token=self.REQUEST_TOKEN)
+                                           request_token=self.REQUEST_TOKEN,
+                                           device_os=self.DEVICE_OS,
+                                           app_version=self.APP_VERSION,
+                                           person_id=self.PERSON_ID,
+                                           custom_properties=self.CUSTOM_PROPERTIES)
 
         mock_token_manager_get.assert_called()
         mock_base_request_post.assert_called_with(Endpoints.SIGNUPS,
@@ -170,6 +316,26 @@ class TestIncogniaAPI(TestCase):
 
         self.assertEqual(response, self.JSON_RESPONSE)
 
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_new_web_signup_when_request_token_is_valid_should_return_full_valid_dict_(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+        response = api.register_new_web_signup(request_token=self.REQUEST_TOKEN,
+                                               policy_id=self.POLICY_ID,
+                                               account_id=self.ACCOUNT_ID,
+                                               custom_properties=self.CUSTOM_PROPERTIES,
+                                               person_id=self.PERSON_ID)
+
+        mock_token_manager_get.assert_called()
+        mock_base_request_post.assert_called_with(Endpoints.SIGNUPS,
+                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
+                                                  data=self.FULL_REGISTER_WEB_SIGNUP_DATA)
+
+        self.assertEqual(response, self.JSON_RESPONSE)
+
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
     def test_register_new_signup_when_request_token_is_empty_should_raise_an_IncogniaError(
@@ -181,6 +347,17 @@ class TestIncogniaAPI(TestCase):
         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_new_web_signup_when_request_token_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_new_web_signup, request_token='')
+
+        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_new_signup_when_request_token_is_invalid_should_raise_an_IncogniaHTTPError(
@@ -196,6 +373,22 @@ class TestIncogniaAPI(TestCase):
                                                   headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
                                                   data=self.REGISTER_INVALID_SIGNUP_DATA)
 
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_new_web_signup_if_request_token_is_invalid_should_raise_an_IncogniaHTTPError(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+        mock_base_request_post.configure_mock(side_effect=IncogniaHTTPError)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        self.assertRaises(IncogniaHTTPError, api.register_new_web_signup,
+                          self.INVALID_REQUEST_TOKEN)
+
+        mock_token_manager_get.assert_called()
+        mock_base_request_post.assert_called_with(Endpoints.SIGNUPS,
+                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
+                                                  data=self.REGISTER_INVALID_WEB_SIGNUP_DATA)
+
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
     def test_register_feedback_when_required_fields_are_valid_should_work(
@@ -224,7 +417,8 @@ class TestIncogniaAPI(TestCase):
                               signup_id=self.SIGNUP_ID,
                               account_id=self.ACCOUNT_ID,
                               installation_id=self.INSTALLATION_ID,
-                              request_token=self.REQUEST_TOKEN)
+                              request_token=self.REQUEST_TOKEN,
+                              person_id=self.PERSON_ID)
 
         mock_token_manager_get.assert_called()
         mock_base_request_post.assert_called_with(Endpoints.FEEDBACKS,
@@ -290,6 +484,39 @@ class TestIncogniaAPI(TestCase):
 
         self.assertEqual(request_response, self.JSON_RESPONSE)
 
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_payment_with_all_fields_should_work(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        request_response = api.register_payment(
+            request_token=self.REQUEST_TOKEN,
+            account_id=self.ACCOUNT_ID,
+            external_id=self.EXTERNAL_ID,
+            location=self.LOCATION,
+            addresses=[self.TRANSACTION_ADDRESS],
+            payment_value=self.PAYMENT_VALUE,
+            payment_methods=self.PAYMENT_METHOD,
+            policy_id=self.POLICY_ID,
+            custom_properties=self.CUSTOM_PROPERTIES,
+            coupon=self.COUPON,
+            device_os=self.DEVICE_OS,
+            app_version=self.APP_VERSION,
+            store_id=self.STORE_ID,
+            person_id=self.PERSON_ID
+        )
+
+        mock_token_manager_get.assert_called()
+        mock_base_request_post.assert_called_with(Endpoints.TRANSACTIONS,
+                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
+                                                  params=self.DEFAULT_PARAMS,
+                                                  data=self.REGISTER_VALID_PAYMENT_DATA_ALL_FIELDS)
+
+        self.assertEqual(request_response, self.JSON_RESPONSE)
+
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
     def test_register_payment_when_request_token_is_empty_should_raise_an_IncogniaError(
@@ -418,6 +645,28 @@ class TestIncogniaAPI(TestCase):
 
         self.assertEqual(request_response, self.JSON_RESPONSE)
 
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_web_login_when_all_fields_are_valid_should_work(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        request_response = api.register_web_login(self.REQUEST_TOKEN,
+                                                  self.ACCOUNT_ID,
+                                                  external_id=self.EXTERNAL_ID,
+                                                  policy_id=self.POLICY_ID,
+                                                  custom_properties=self.CUSTOM_PROPERTIES,
+                                                  person_id=self.PERSON_ID)
+        mock_token_manager_get.assert_called()
+        mock_base_request_post.assert_called_with(Endpoints.TRANSACTIONS,
+                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
+                                                  params=self.DEFAULT_PARAMS,
+                                                  data=self.REGISTER_VALID_WEB_LOGIN_ALL_FIELDS)
+
+        self.assertEqual(request_response, self.JSON_RESPONSE)
+
     @patch.object(BaseRequest, 'post')
     @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
     def test_register_web_login_when_request_token_is_empty_should_raise_an_IncogniaError(
@@ -461,3 +710,200 @@ class TestIncogniaAPI(TestCase):
                                                   headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
                                                   params=self.DEFAULT_PARAMS,
                                                   data=self.REGISTER_INVALID_WEB_LOGIN_DATA)
+
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_login_with_valid_location_should_work(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        request_response = api.register_login(self.REQUEST_TOKEN,
+                                              self.ACCOUNT_ID,
+                                              location=self.LOCATION,
+                                              policy_id=self.POLICY_ID)
+
+        mock_token_manager_get.assert_called()
+        mock_base_request_post.assert_called_with(Endpoints.TRANSACTIONS,
+                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
+                                                  params=self.DEFAULT_PARAMS,
+                                                  data=self.REGISTER_VALID_LOGIN_DATA_WITH_LOCATION)
+
+        self.assertEqual(request_response, self.JSON_RESPONSE)
+
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_login_with_all_fields_should_work(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        request_response = api.register_login(self.REQUEST_TOKEN,
+                                              self.ACCOUNT_ID,
+                                              location=self.LOCATION,
+                                              external_id=self.EXTERNAL_ID,
+                                              policy_id=self.POLICY_ID,
+                                              device_os=self.DEVICE_OS,
+                                              app_version=self.APP_VERSION,
+                                              person_id=self.PERSON_ID)
+
+        mock_token_manager_get.assert_called()
+        mock_base_request_post.assert_called_with(Endpoints.TRANSACTIONS,
+                                                  headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
+                                                  params=self.DEFAULT_PARAMS,
+                                                  data=self.REGISTER_VALID_LOGIN_DATA_ALL_FIELDS)
+
+        self.assertEqual(request_response, self.JSON_RESPONSE)
+
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_login_with_location_and_empty_latitude_should_raise_an_IncogniaError(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        self.assertRaises(
+            IncogniaError, api.register_login,
+            self.REQUEST_TOKEN,
+            self.ACCOUNT_ID,
+            location=self.INVALID_LOCATION_EMPTY_LATITUDE,
+            policy_id=self.POLICY_ID,
+        )
+
+        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_login_with_location_and_empty_longitude_should_raise_an_IncogniaError(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        self.assertRaises(
+            IncogniaError,
+            api.register_login,
+            self.REQUEST_TOKEN,
+            self.ACCOUNT_ID,
+            location=self.INVALID_LOCATION_EMPTY_LONGITUDE,
+            policy_id=self.POLICY_ID,
+        )
+
+        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_login_with_location_and_wrong_timestamp_should_raise_an_IncogniaError(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        self.assertRaises(
+            IncogniaError,
+            api.register_login,
+            self.REQUEST_TOKEN,
+            self.ACCOUNT_ID,
+            location=self.INVALID_LOCATION_WRONG_TIMESTAMP,
+            policy_id=self.POLICY_ID,
+        )
+
+        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_payment_with_valid_location_should_work(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        request_response = api.register_payment(
+            self.REQUEST_TOKEN,
+            self.ACCOUNT_ID,
+            location=self.LOCATION,
+            policy_id=self.POLICY_ID,
+        )
+
+        mock_token_manager_get.assert_called()
+        mock_base_request_post.assert_called_with(
+            Endpoints.TRANSACTIONS,
+            headers=self.AUTH_AND_JSON_CONTENT_HEADERS,
+            params=self.DEFAULT_PARAMS,
+            data=self.REGISTER_VALID_PAYMENT_DATA_WITH_LOCATION,
+        )
+
+        self.assertEqual(request_response, self.JSON_RESPONSE)
+
+    @patch.object(BaseRequest, 'post')
+    @patch.object(TokenManager, 'get', return_value=TOKEN_VALUES)
+    def test_register_payment_with_location_and_empty_latitude_should_raise_an_IncogniaError(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        self.assertRaises(
+            IncogniaError, api.register_payment,
+            self.REQUEST_TOKEN,
+            self.ACCOUNT_ID,
+            location=self.INVALID_LOCATION_EMPTY_LATITUDE,
+            policy_id=self.POLICY_ID,
+        )
+
+        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_payment_with_location_and_empty_longitude_should_raise_an_IncogniaError(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        self.assertRaises(
+            IncogniaError, api.register_payment,
+            self.REQUEST_TOKEN,
+            self.ACCOUNT_ID,
+            location=self.INVALID_LOCATION_EMPTY_LONGITUDE,
+            policy_id=self.POLICY_ID,
+        )
+
+        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_payment_with_location_and_wrong_timestamp_should_raise_an_IncogniaError(
+            self, mock_token_manager_get: Mock, mock_base_request_post: Mock):
+
+        mock_base_request_post.configure_mock(return_value=self.JSON_RESPONSE)
+
+        api = IncogniaAPI(self.CLIENT_ID, self.CLIENT_SECRET)
+
+        self.assertRaises(
+            IncogniaError,
+            api.register_payment,
+            self.REQUEST_TOKEN,
+            self.ACCOUNT_ID,
+            location=self.INVALID_LOCATION_WRONG_TIMESTAMP,
+            policy_id=self.POLICY_ID,
+        )
+
+        mock_token_manager_get.assert_not_called()
+        mock_base_request_post.assert_not_called()

incognia_python-3.0.0/incognia/datetime_util.py

@@ -1,5 +0,0 @@
-import datetime as dt
-
-
-def has_timezone(d: dt.datetime) -> bool:
-    return d.tzinfo is not None and d.tzinfo.utcoffset(d) is not None