Add and Remove Authorized Users for a Customer (unit-finance#168)

* there is an infinite loop if max_retries set to 0
global _retries isn't passed properly to backoff_predicated, I've added a get function for this var

* add and remove authorized users for customer
added tests

* max_retries must be greater than 0

* max_tries must be greater than 0 due to infinite loop of backoff library otherwise

* typo

Author: axshani

e2e_tests/customer_test.py

@@ -3,29 +3,48 @@
 from unit import Unit
 from unit.models.customer import *
 from unit.models.codecs import DtoDecoder
+from e2e_tests.helpers.helpers import create_individual_customer
 
 token = os.environ.get('TOKEN')
 client = Unit("https://api.s.unit.sh", token)
 
+authorized_users = [
+    {
+        "fullName": {
+            "first": "Jared",
+            "last": "Dunn"
+        },
+        "email": "[email protected]",
+        "phone": {
+            "countryCode": "1",
+            "number": "1555555590"
+        }
+    }
+]
+
+
 def get_customer_by_type(type: str):
-    response = client.customers.list(ListCustomerParams(0,1000))
+    response = client.customers.list(ListCustomerParams(0, 1000))
     for c in response.data:
         if c.type == type:
             return c
     return None
 
+
 def test_update_individual_customer():
     individual_customer_id = get_customer_by_type("individualCustomer").id
     request = PatchIndividualCustomerRequest(individual_customer_id, phone=Phone("1", "1115551111"))
     response = client.customers.update(request)
     assert response.data.type == "individualCustomer"
 
+
 def test_update_business_customer():
     business_customer_id = get_customer_by_type("businessCustomer").id
     request = PatchBusinessCustomerRequest(business_customer_id, phone=Phone("1", "1115551111"))
     response = client.customers.update(request)
     assert response.data.type == "businessCustomer"
 
+
 def test_get_customer():
     customer_ids = []
     response = client.customers.list()
@@ -36,6 +55,7 @@ def test_get_customer():
         response = client.customers.get(id)
         assert response.data.type == "individualCustomer" or response.data.type == "businessCustomer"
 
+
 def test_list_customers():
     response = client.customers.list()
     for customer in response.data:
@@ -44,91 +64,58 @@ def test_list_customers():
 
 def test_business_customer():
     business_customer_api_response = {
-          "type": "businessCustomer",
-          "id": "1",
-          "attributes": {
+        "type": "businessCustomer",
+        "id": "1",
+        "attributes": {
             "createdAt": "2020-05-10T12:28:37.698Z",
             "name": "Pied Piper",
             "address": {
-              "street": "5230 Newell Rd",
-              "street2": None,
-              "city": "Palo Alto",
-              "state": "CA",
-              "postalCode": "94303",
-              "country": "US"
+                "street": "5230 Newell Rd",
+                "street2": None,
+                "city": "Palo Alto",
+                "state": "CA",
+                "postalCode": "94303",
+                "country": "US"
             },
             "phone": {
-              "countryCode": "1",
-              "number": "1555555578"
+                "countryCode": "1",
+                "number": "1555555578"
             },
             "stateOfIncorporation": "DE",
             "ein": "123456789",
             "entityType": "Corporation",
             "contact": {
-              "fullName": {
-                "first": "Richard",
-                "last": "Hendricks"
-              },
-              "email": "[email protected]",
-              "phone": {
-                "countryCode": "1",
-                "number": "1555555578"
-              }
-            },
-            "authorizedUsers": [
-              {
                 "fullName": {
-                  "first": "Jared",
-                  "last": "Dunn"
+                    "first": "Richard",
+                    "last": "Hendricks"
                 },
-                "email": "jared@piedpiper.com",
+                "email": "richard@piedpiper.com",
                 "phone": {
-                  "countryCode": "1",
-                  "number": "1555555590"
+                    "countryCode": "1",
+                    "number": "1555555578"
                 }
-              },
-                {
-                    "fullName": {
-                        "first": "Jared",
-                        "last": "Dunn"
-                    },
-                    "email": "[email protected]",
-                    "phone": {
-                        "countryCode": "1",
-                        "number": "1555555590"
-                    }
-                },{
-                "fullName": {
-                  "first": "Jared",
-                  "last": "Dunn"
-                },
-                "email": "[email protected]",
-                "phone": {
-                  "countryCode": "1",
-                  "number": "1555555590"
-                }
-              }
-            ],
+            },
+            "authorizedUsers": authorized_users,
             "status": "Active",
             "tags": {
-              "userId": "106a75e9-de77-4e25-9561-faffe59d7814"
+                "userId": "106a75e9-de77-4e25-9561-faffe59d7814"
             }
-          },
-          "relationships": {
+        },
+        "relationships": {
             "org": {
-              "data": {
-                "type": "org",
-                "id": "1"
-              }
+                "data": {
+                    "type": "org",
+                    "id": "1"
+                }
             },
             "application": {
-              "data": {
-                "type": "businessApplication",
-                "id": "1"
-              }
+                "data": {
+                    "type": "businessApplication",
+                    "id": "1"
+                }
             }
-          }
         }
+    }
 
     id = business_customer_api_response["id"]
     _type = business_customer_api_response["type"]
@@ -144,6 +131,7 @@ def test_business_customer():
     assert customer.attributes["authorizedUsers"][0].full_name.first == "Jared"
     assert customer.attributes["status"] == "Active"
 
+
 def test_individual_customer():
     individual_customer_api_response = {
         "type": "individualCustomer",
@@ -191,7 +179,6 @@ def test_individual_customer():
         }
     }
 
-
     id = individual_customer_api_response["id"]
     _type = individual_customer_api_response["type"]
 
@@ -207,3 +194,28 @@ def test_individual_customer():
     assert customer.attributes["authorizedUsers"] == []
     assert customer.attributes["status"] == "Active"
 
+
+def add_authorized_users_to_individual_customer():
+    individual_customer_id = create_individual_customer(client)
+    request = AddAuthorizedUsersRequest(individual_customer_id, authorized_users)
+    return client.customers.add_authorized_users(request)
+
+
+def test_add_authorized_users_to_individual_customer():
+    response = add_authorized_users_to_individual_customer()
+    assert response.data.type == "individualCustomer"
+    assert len(response.data.attributes.get("authorizedUsers")) == 1
+    assert response.data.attributes.get("authorizedUsers")[0].email == authorized_users[0].get("email")
+
+
+def test_remove_authorized_users_to_individual_customer():
+    add_response = add_authorized_users_to_individual_customer()
+    assert add_response.data.type == "individualCustomer"
+    assert len(add_response.data.attributes.get("authorizedUsers")) == 1
+    assert add_response.data.attributes.get("authorizedUsers")[0].email == authorized_users[0].get("email")
+    authorized_users_emails = [authorized_users[0].get("email")]
+    request = RemoveAuthorizedUsersRequest(add_response.data.id, authorized_users_emails)
+    remove_response = client.customers.remove_authorized_users(request)
+    assert remove_response.data.id == add_response.data.id
+    assert remove_response.data.type == add_response.data.type
+    assert len(remove_response.data.attributes.get("authorizedUsers")) == 0

unit/__init__.py

@@ -28,7 +28,7 @@
 
 
 class Unit(object):
-    def __init__(self, api_url, token, retries=0):
+    def __init__(self, api_url, token, retries=1):
         self.applications = ApplicationResource(api_url, token, retries)
         self.customers = CustomerResource(api_url, token, retries)
         self.accounts = AccountResource(api_url, token, retries)

unit/api/base_resource.py

@@ -4,7 +4,11 @@
 from typing import Optional, Dict
 from unit.models.codecs import UnitEncoder
 
-retries = 0
+_retries = 1
+
+
+def get_max_retries():
+    return _retries
 
 
 def backoff_idempotency_key_handler(e):
@@ -38,7 +42,7 @@ def idempotency_key_is_present(e):
 
 class BaseResource(object):
     def __init__(self, api_url, token, retries_amount):
-        global retries
+        global _retries
 
         self.api_url = api_url.rstrip("/")
         self.token = token
@@ -47,51 +51,51 @@ def __init__(self, api_url, token, retries_amount):
             "authorization": f"Bearer {self.token}",
             "user-agent": "unit-python-sdk"
         }
-        retries = retries_amount
+        # max_tries must be greater than 0 due to an infinite loop of backoff library otherwise
+        _retries = retries_amount if retries_amount > 1 else 1
 
     @backoff.on_predicate(backoff.expo,
                           backoff_handler,
-                          max_tries=retries,
+                          max_tries=get_max_retries,
                           jitter=backoff.random_jitter)
     def get(self, resource: str, params: Dict = None, headers: Optional[Dict[str, str]] = None):
         return requests.get(f"{self.api_url}/{resource}", params=params, headers=self.__merge_headers(headers))
 
     @backoff.on_predicate(backoff.expo,
                           backoff_handler,
-                          max_tries=retries,
+                          max_tries=get_max_retries,
                           jitter=backoff.random_jitter)
     def post(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
-        return requests.post(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))\
-
+        return requests.post(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
 
     @backoff.on_predicate(backoff.expo,
                           backoff_idempotency_key_handler,
-                          max_tries=retries,
+                          max_tries=get_max_retries,
                           jitter=backoff.random_jitter)
     def post_create(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
         return requests.post(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
 
     @backoff.on_predicate(backoff.expo,
                           backoff_handler,
-                          max_tries=retries,
+                          max_tries=get_max_retries,
                           jitter=backoff.random_jitter)
     def patch(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
         return requests.patch(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
 
     @backoff.on_predicate(backoff.expo,
                           backoff_handler,
-                          max_tries=retries,
+                          max_tries=get_max_retries,
                           jitter=backoff.random_jitter)
     def delete(self, resource: str, data: Dict = None, headers: Optional[Dict[str, str]] = None):
         data = json.dumps(data, cls=UnitEncoder) if data is not None else None
         return requests.delete(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
 
     @backoff.on_predicate(backoff.expo,
                           backoff_handler,
-                          max_tries=retries,
+                          max_tries=get_max_retries,
                           jitter=backoff.random_jitter)
     def put(self, resource: str, data: Optional[Dict] = None, headers: Optional[Dict[str, str]] = None):
         return requests.put(f"{self.api_url}/{resource}", data=data, headers=self.__merge_headers(headers))
@@ -106,4 +110,3 @@ def __merge_headers(self, headers: Optional[Dict[str, str]] = None):
 
     def is_20x(self, status: int):
         return status == 200 or status == 201 or status == 204
-

unit/api/customer_resource.py

@@ -8,22 +8,19 @@ def __init__(self, api_url, token, retries):
         super().__init__(api_url, token, retries)
         self.resource = "customers"
 
-    def update(self, request: Union[PatchIndividualCustomerRequest, PatchBusinessCustomerRequest]) -> Union[UnitResponse[CustomerDTO], UnitError]:
+    def update(self, request: PatchCustomerRequest) -> Union[UnitResponse[CustomerDTO], UnitError]:
         payload = request.to_json_api()
         response = super().patch(f"{self.resource}/{request.customer_id}", payload)
 
-        if response.ok:
+        if super().is_20x(response.status_code):
             data = response.json().get("data")
-            if data["type"] == "individualCustomer":
-                return UnitResponse[IndividualCustomerDTO](DtoDecoder.decode(data), None)
-            else:
-                return UnitResponse[BusinessCustomerDTO](DtoDecoder.decode(data), None)
+            return UnitResponse[CustomerDTO](DtoDecoder.decode(data), None)
         else:
             return UnitError.from_json_api(response.json())
 
     def get(self, customer_id: str) -> Union[UnitResponse[CustomerDTO], UnitError]:
         response = super().get(f"{self.resource}/{customer_id}")
-        if response.status_code == 200:
+        if super().is_20x(response.status_code):
             data = response.json().get("data")
             return UnitResponse[CustomerDTO](DtoDecoder.decode(data), None)
         else:
@@ -32,7 +29,7 @@ def get(self, customer_id: str) -> Union[UnitResponse[CustomerDTO], UnitError]:
     def list(self, params: ListCustomerParams = None) -> Union[UnitResponse[List[CustomerDTO]], UnitError]:
         params = params or ListCustomerParams()
         response = super().get(self.resource, params.to_dict())
-        if response.status_code == 200:
+        if super().is_20x(response.status_code):
             data = response.json().get("data")
             return UnitResponse[CustomerDTO](DtoDecoder.decode(data), None)
         else:
@@ -46,3 +43,22 @@ def archive(self, request: ArchiveCustomerRequest) -> Union[UnitResponse[Custome
             return UnitResponse[CustomerDTO](DtoDecoder.decode(data), None)
         else:
             return UnitError.from_json_api(response.json())
+
+    def add_authorized_users(self, request: AddAuthorizedUsersRequest) -> Union[UnitResponse[CustomerDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().post(f"{self.resource}/{request.customer_id}/authorized-users", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[CustomerDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())
+
+    def remove_authorized_users(self, request: RemoveAuthorizedUsersRequest) -> Union[UnitResponse[CustomerDTO], UnitError]:
+        payload = request.to_json_api()
+        response = super().delete(f"{self.resource}/{request.customer_id}/authorized-users", payload)
+        if super().is_20x(response.status_code):
+            data = response.json().get("data")
+            return UnitResponse[CustomerDTO](DtoDecoder.decode(data), None)
+        else:
+            return UnitError.from_json_api(response.json())
+