mailbox-org-api 2.1__tar.gz → 2.3__tar.gz

{mailbox_org_api-2.1 → mailbox_org_api-2.3}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mailbox-org-api
-Version: 2.1
-Summary: A library to access the mailbox.org Business API.
+Version: 2.3
+Summary: A library to access the mailbox Business API.
 Author: Hendrik Schlange
 Author-email: Hendrik Schlange <mail@heshsum.de>
 Project-URL: Homepage, https://github.com/heshsum/mailbox-org-api
@@ -9,7 +9,7 @@ Project-URL: Issues, https://github.com/heshsum/mailbox-org-api/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: author

{mailbox_org_api-2.1 → mailbox_org_api-2.3}/mailbox_org_api/APIClient.py

@@ -2,15 +2,18 @@
 Module for the mailbox Business API client
 """
 import json
+from typing import Any
+
 import requests
+import typing_extensions
 from requests.adapters import HTTPAdapter
-from urllib3.util.retry import Retry
 from requests.exceptions import RequestException
-import typing_extensions
+from urllib3.util.retry import Retry
+
 from mailbox_org_api.APIError import APIError
 from mailbox_org_api.Account import Account
-from mailbox_org_api.Mail import Mail
 from mailbox_org_api.Invoice import Invoice
+from mailbox_org_api.Mail import Mail
 
 headers = {'content-type': 'application/json'}
 
@@ -62,7 +65,7 @@ class APIClient:
         self.jsonrpc_id += 1
         return str(self.jsonrpc_id)
 
-    def api_request(self, method: str, params: dict) -> dict:
+    def api_request(self, method: str, params: dict) -> dict | Any:
         """
         Function to send API calls
         :param method: the method to call
@@ -365,7 +368,7 @@ class APIClient:
         # Take the Base64 encoded data (response['bin']), decode the Base 64, decompress the gz and return the bytes
         return zlib.decompress(base64.b64decode(response['bin']))
 
-    def domain_list(self, account: str, search_filter:str = None) -> dict:
+    def domain_list(self, account:str, search_filter:str | None = None) -> dict:
         """
         Function to list all domains
         :param account: the account to list domains for
@@ -373,8 +376,8 @@ class APIClient:
         :return: the API response
         """
         params = {'account':account}
-        if filter:
-            params.update({'filter':search_filter})
+        if isinstance(search_filter, str):
+            params.update({'filter':str(search_filter)})
         return self.api_request('domain.list',params)
 
     def domain_add(self, account: str, domain: str, password: str, **kwargs) -> dict:
@@ -452,8 +455,8 @@ class APIClient:
         """
         return self.api_request('domain.validate.spf', {'domain':domain})
 
-    def mail_list(self, domain: str, details: bool = False, page_size: int = None, page: int = None, sort_field: str = None,
-                  sort_order: str = None) -> dict:
+    def mail_list(self, domain: str, details: bool = False, page_size: int  | None= None, page: int | None = None,
+                  sort_field: str | None = None, sort_order: str | None = None) -> dict:
         """
         Function to list all mailboxes
         :param domain: the domain to list
@@ -488,7 +491,7 @@ class APIClient:
         return self.api_request('mail.list', params)
 
     def mail_add(self, mail:str, password: str, plan: str, first_name: str, last_name: str, inboxsave: bool = True,
-                 forwards: list = None, **kwargs) -> dict:
+                 forwards: list | None= None, **kwargs) -> dict:
         """
         Function to add a mail
         :param mail: the mail to add
@@ -564,7 +567,10 @@ class APIClient:
 
         if 'password' in kwargs and 'password_hash' in kwargs:
           raise KeyError('''Simultaneous usage of 'password' and 'password_hash' not allowed.''')
-        
+
+        if 'additional_mail_quota' in kwargs or 'additional_cloud_quota' in kwargs and 'plan' not in kwargs:
+            raise KeyError('''If setting additional quota, 'plan' must be given.''')
+
         # Check for each argument in kwargs if it is a valid function parameter.
         # Check key and type of value. Raise errors if a check fails.
 
@@ -634,6 +640,27 @@ class APIClient:
         """
         return self.api_request('mail.set', {'mail':mail, 'active':active})
 
+    def mail_set_additional_mail_quota(self, mail: str, quota: int) -> dict:
+        """
+        Function to set additional mail quota for a given mail
+        :param mail: the mail to set the quota for
+        :param quota: the quota to set
+        :return: the response for the request
+        """
+        plan = self.mail_get(mail)['plan']
+        return self.api_request('mail.set', {'mail': mail, 'plan':plan, 'additional_mail_quota':quota})
+
+    def mail_set_additional_cloud_quota(self, mail: str, quota: int) -> dict:
+        """
+        Function to set additional cloud quota for a given mail
+        :param mail: the mail to set the quota for
+        :param quota: the quota to set
+        :return: the response for the request
+        """
+        plan = self.mail_get(mail)['plan']
+        return self.api_request('mail.set', {'mail': mail, 'plan': plan,
+                                             'additional_cloud_quota': quota})
+
     def mail_set_deletion_date(self, mail: str, deletion_date: str) -> dict:
         """
         Function to delete an inbox at a given date.
@@ -794,7 +821,7 @@ class APIClient:
         return self.api_request('mail.vacation.get', {'mail':mail})
 
     def mail_vacation_set(self, mail: str, subject: str, body: str, start_date: str, end_date: str,
-                          additional_mail_addresses: list = None) -> dict:
+                          additional_mail_addresses: list | None = None) -> dict:
         """
         Function to set the vacation notice for a given mail
         :param mail: the mail to get the vacation notice for
@@ -814,57 +841,75 @@ class APIClient:
 
         return self.api_request('mail.vacation.set', params)
 
-    def group_list(self) -> dict:
+    def group_list(self, account:str | None = None) -> dict:
         """
         Function to list all groups for an account
+        :param account: optional parameter for the account to list the groups for
         :return: mailbox API response - the list of groups
         """
-        return self.api_request('group.list', {})
+        params = {}
+        if account:
+            params['account'] = account
+        return self.api_request('group.list', params)
 
-    def group_get(self, group_id: int) -> dict:
+    def group_get(self, group_id: int, account: str | None = None) -> dict:
         """
         Function to get a group from the account by the group id
         :param group_id: the id of the group to get
+        :param account: optional parameter for the account to get the group for
         :return: mailbox API response - the list of groups of the account
         """
-        return self.api_request('group.get', {'group_id':group_id})
+        params = {'group_id': group_id}
+        if account:
+            params['account'] = account
+        return self.api_request('group.get', params)
 
-    def group_del(self, group_id: int) -> dict:
+    def group_del(self, group_id: int, account: str | None = None) -> dict:
         """
         Function to delete a group
         :param group_id: the group's id of the group to delete
+        :param account: optional parameter for the account to delete the group for
         :return: mailbox API response - True if the group was deleted, False otherwise
         """
-        return self.api_request('group.del', {'group_id':group_id})
+        params = {'group_id': group_id}
+        if account:
+            params['account'] = account
+        return self.api_request('group.del', params)
 
-    def group_add(self, name: str, display_name: str, mail_addresses_to_add: list) -> dict:
+    def group_add(self, name: str, display_name: str, mail_addresses_to_add: list, account: str | None = None) -> dict:
         """
         Function to add a group
         :param name: the group name
         :param display_name: the group's display name
         :param mail_addresses_to_add: a list of mail addresses to add
+        :param account: optional parameter for the account to add the group for
         :return: mailbox API response - True if the group was added, False otherwise
         """
-        return self.api_request('group.add', {'name':name, 'display_name':display_name,
-                                              'mail_addresses_to_add':mail_addresses_to_add})
+        params = {'name':name, 'display_name':display_name, 'mail_addresses_to_add':mail_addresses_to_add}
+        if account:
+            params['account'] = account
+        return self.api_request('group.add', params)
 
-    def group_set(self, group_id: int, display_name: str, mail_addresses_to_add: list = None,
-                  mail_addresses_to_remove: list = None) -> dict:
+    def group_set(self, group_id: int, display_name: str, mail_addresses_to_add: list | None = None,
+                  mail_addresses_to_remove: list | None = None, account: str | None= None) -> dict:
         """
         Function to modify a group. Either mail_addresses_to_add or mail_addresses_to_remove have to be specified.
         :param group_id: the group's id of the group to modify
         :param display_name: the group's display name
         :param mail_addresses_to_add: a list of mail addresses to add. Defaults to None
         :param mail_addresses_to_remove: a list of mail addresses to remove. Defaults to None
+        :param account: optional parameter for the account to set the group for
         :return: mailbox API response - True if the group was edited, False otherwise
         """
         # If mail_addresses_to_add and mail_addresses_to_remove are both empty, raise error
         if mail_addresses_to_add is None and mail_addresses_to_remove is None:
             raise ValueError('mail_addresses_to_add or mail_addresses_to_remove are required')
 
-        return self.api_request('group.set', {'group_id':group_id, 'display_name':display_name,
-                                              'mail_addresses_to_add':mail_addresses_to_add,
-                                              'mail_addresses_to_remove':mail_addresses_to_remove})
+        params = {'group_id':group_id, 'display_name':display_name, 'mail_addresses_to_add':mail_addresses_to_add,
+                  'mail_addresses_to_remove':mail_addresses_to_remove}
+        if account:
+            params['account'] = account
+        return self.api_request('group.set', params)
 
     def mail_passwordreset_listmethods(self, mail: str) -> dict:
         """
@@ -921,7 +966,7 @@ class APIClient:
         """
         return self.api_request('mailinglist.list', {'account':account})
 
-    def mailinglist_add(self, mailinglist: str, password: str, account: str, adminmail: str = None) -> dict:
+    def mailinglist_add(self, mailinglist: str, password: str, account: str, adminmail: str | None = None) -> dict:
         """
         Function to add a mailing list
         :param mailinglist: the mailing list to add
@@ -942,7 +987,8 @@ class APIClient:
         """
         return self.api_request('mailinglist.get', {'mailinglist':mailinglist, 'account':account})
 
-    def mailinglist_set(self, mailinglist: str, account: str, password: str = None, adminmail: str = None) -> dict:
+    def mailinglist_set(self, mailinglist: str, account: str, password: str | None = None,
+                        adminmail: str | None = None) -> dict:
         """
         Function to change a mailing list
         :param mailinglist: the mailing list to change
@@ -954,17 +1000,25 @@ class APIClient:
         return self.api_request('mailinglist.set', {'mailinglist':mailinglist, 'account':account,
                                                 'password':password, 'adminmail':adminmail})
 
-    def mailinglist_delete(self, mailinglist: str, account: str) -> dict:
+    def mailinglist_del(self, mailinglist: str, account: str) -> dict:
         """
         Function to delete a mailing list
         :param mailinglist: the mailing list to delete
         :param account: the account of the mailing list
         :return: the mailbox API response for the request - True if the mailing list was deleted, error code otherwise
         """
-        return self.api_request('mailinglist.delete', {'mailinglist':mailinglist, 'account':account})
+        return self.api_request('mailinglist.del', {'mailinglist':mailinglist, 'account':account})
+
+    def additionalmailaccount_list(self, parent_mail: str) -> dict:
+        """
+        Function to list all additional mail accounts for a given parent mail
+        :param parent_mail: the parent mail to list additional mail accounts for
+        :return: a dict containing the parent mail account and a list of additional mail accounts
+        """
+        return self.api_request('additionalmailaccount.list', {'parent_mail':parent_mail})
 
     def additionalmailaccount_add(self, parent_mail: str, new_account_mail: str, new_account_password: str,
-                                  primary_address: str = None, mail_server: str = 'imap.mailbox.org',
+                                  primary_address: str | None = None, mail_server: str = 'imap.mailbox.org',
                                   mail_port: int = 993, mail_secure: bool = True, mail_starttls: bool = False,
                                   transport_server: str = 'smtp.mailbox.org', transport_port: int = 465,
                                   transport_secure: bool = True, transport_starttls: bool = False,

{mailbox_org_api-2.1 → mailbox_org_api-2.3}/mailbox_org_api.egg-info/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.4
 Name: mailbox-org-api
-Version: 2.1
-Summary: A library to access the mailbox.org Business API.
+Version: 2.3
+Summary: A library to access the mailbox Business API.
 Author: Hendrik Schlange
 Author-email: Hendrik Schlange <mail@heshsum.de>
 Project-URL: Homepage, https://github.com/heshsum/mailbox-org-api
@@ -9,7 +9,7 @@ Project-URL: Issues, https://github.com/heshsum/mailbox-org-api/issues
 Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.8
+Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Dynamic: author

{mailbox_org_api-2.1 → mailbox_org_api-2.3}/pyproject.toml

@@ -1,12 +1,12 @@
 [project]
 name = "mailbox-org-api"
-version = "2.1"
+version = "2.3"
 authors = [
   { name="Hendrik Schlange", email="mail@heshsum.de" },
 ]
-description = "A library to access the mailbox.org Business API."
+description = "A library to access the mailbox Business API."
 readme = "README.md"
-requires-python = ">=3.8"
+requires-python = ">=3.11"
 classifiers = [
     "Programming Language :: Python :: 3",
     "License :: OSI Approved :: MIT License",
@@ -18,7 +18,7 @@ Homepage = "https://github.com/heshsum/mailbox-org-api"
 Issues = "https://github.com/heshsum/mailbox-org-api/issues"
 
 [build-system]
-requires = ["setuptools>=61.0"]
+requires = ["setuptools>=70.0"]
 build-backend = "setuptools.build_meta"
 
 [tool.pytest.ini_options]

{mailbox_org_api-2.1 → mailbox_org_api-2.3}/setup.py

@@ -3,8 +3,8 @@ from setuptools import find_packages, setup
 setup(
     name='mailbox_org_api',
     packages=find_packages(),
-    version='2.1',
-    description='A library to access the mailbox.org Business API',
+    version='2.3',
+    description='A library to access the mailbox Business API',
     author='Hendrik Schlange',
     install_requires=['requests'],
     tests_require=['pytest'],

{mailbox_org_api-2.1 → mailbox_org_api-2.3}/tests/TestAPIClient.py

@@ -15,9 +15,26 @@ def generate_id():
     return str(int(time.time()))
 
 def generate_pw():
-    alphabet = string.ascii_letters + string.digits
-    password = ''.join(secrets.choice(alphabet) for i in range(42))
-    return password
+    # Length of password
+    length = 42
+    # Required character sets
+    upper = string.ascii_uppercase
+    lower = string.ascii_lowercase
+    digits = string.digits
+    special = '!$"%%&/()'
+
+    # Combine all allowed characters
+    all_chars = upper + lower + digits + special
+    while True:
+        # Generate a random string of the specified length
+        pw = ''.join(secrets.choice(all_chars) for _ in range(length))
+
+        # Ensure the password meets all criteria
+        if (any(c in upper for c in pw) and
+                any(c in lower for c in pw) and
+                any(c in digits for c in pw) and
+                any(c in special for c in pw)):
+            return pw
 
 def get_domain():
     api = APIClient.APIClient()
@@ -289,7 +306,7 @@ class TestAPIClient:
         assert returned_mail['mail'] == mail
         api.deauth()
 
-    @pytest.mark.depends(name=['test_mail_add'])
+    @pytest.mark.depends(name='test_mail_add')
     def test_mail_set(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -302,7 +319,7 @@ class TestAPIClient:
                           'memo': 'memo_string', 'active': True, 'title': 'Title', 'position': 'Job Position',
                           'department': 'Department', 'company': 'Company', 'street': 'Street 1',
                           'postal_code': '12345', 'city': 'City', 'phone':'+492345678', 'fax':'+492345678',
-                          'cell_phone':'+492345678', 'uid_extern': generate_pw(), 'language': 'de_DE'}
+                          'cell_phone':'+492345678', 'uid_extern': 'external_uid_value', 'language': 'de_DE'}
 
         # Adding parameters to call
         params = {}
@@ -311,14 +328,23 @@ class TestAPIClient:
 
         # Getting mail from API to act as the reference
         check_mail = api.mail_get(mail)
-
+        print(check_mail)
         # Compare values sent to values received
         for k, v in mail_set_tests.items():
             assert check_mail[k] == v
 
+        with pytest.raises(KeyError):
+            api.mail_set(mail, additional_mail_quota=5)
+
+        with pytest.raises(KeyError):
+            api.mail_set(mail, additional_cloud_quota=5)
+
+        with pytest.raises(KeyError):
+            api.mail_set(mail, additional_mail_quota = 5, additional_cloud_quota=5)
+
         api.deauth()
 
-    @pytest.mark.depends(name=["test_mail_add"])
+    @pytest.mark.depends(name="test_mail_add")
     def test_mail_capabilities_set(self):
         capabilities = ['MAIL_SPAMPROTECTION', 'MAIL_BLACKLIST', 'MAIL_BACKUPRECOVER', 'MAIL_PASSWORDRESET_SMS']
 
@@ -352,22 +378,20 @@ class TestAPIClient:
         api.auth(api_test_user, api_test_pass)
         mails = api.mail_list(domain)
         mail = mails[0]['mail']
-        plans = ['standard', 'premium']
+        plans = ['premium', 'light', 'standard']
         for plan in plans:
             api.mail_set_plan(mail, plan)
             assert str(api.mail_get(mail)['plan']).lower() == plan
-        with pytest.raises(APIError):
-            api.mail_set_plan(mail, 'light')
         api.deauth()
 
-    @pytest.mark.depends(name=["test_mail_add"])
+    @pytest.mark.depends(name="test_mail_add")
     def test_mail_set_aliases(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
         mail = test_id + '@' + domain
         aliases = []
         api.mail_set_aliases(mail, aliases)
-        for i in range(0, 5):
+        for i in range(0, 2):
             address = test_id + '_alias_' + str(i) + '@' + domain
             aliases.append(address)
         api.mail_set_aliases(mail, aliases)
@@ -376,7 +400,7 @@ class TestAPIClient:
         assert api.mail_get(mail)['aliases'] == []
         api.deauth()
 
-    @pytest.mark.depends(name=["test_mail_add"])
+    @pytest.mark.depends(name="test_mail_add")
     def test_mail_set_forwards(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -390,7 +414,7 @@ class TestAPIClient:
         assert api.mail_get(mail)['forwards'] == forwards
         api.deauth()
 
-    @pytest.mark.depends(name=["test_mail_add"])
+    @pytest.mark.depends(name="test_mail_add")
     def test_mail_set_password(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -400,7 +424,7 @@ class TestAPIClient:
         assert api.mail_set_password(mail, generate_pw()) == api.mail_get(mail)
         api.deauth()
 
-    @pytest.mark.depends(name=["test_mail_add"])
+    @pytest.mark.depends(name="test_mail_add")
     def test_mail_set_password_require_reset(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -410,7 +434,25 @@ class TestAPIClient:
         assert api.mail_set_password_require_reset(mail, generate_pw()) == api.mail_get(mail)
         api.deauth()
 
-    @pytest.mark.depends(name=["test_mail_add"])
+    def test_mail_set_additional_mail_quota(self):
+        api = APIClient.APIClient()
+        api.auth(api_test_user, api_test_pass)
+        mail = test_id + '@' + domain
+        additional_mail_quota = 23
+        api.mail_set_additional_mail_quota(mail, additional_mail_quota)
+        assert additional_mail_quota == api.mail_get(mail)['additional_mail_quota']
+        api.deauth()
+
+    def test_mail_set_additional_cloud_quota(self):
+        api = APIClient.APIClient()
+        api.auth(api_test_user, api_test_pass)
+        mail = test_id + '@' + domain
+        additional_cloud_quota = 42
+        api.mail_set_additional_cloud_quota(mail, additional_cloud_quota)
+        assert additional_cloud_quota == api.mail_get(mail)['additional_cloud_quota']
+        api.deauth()
+
+    @pytest.mark.depends(name="test_mail_add")
     def test_mail_apppassword_add(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -420,7 +462,7 @@ class TestAPIClient:
         assert len(api.mail_apppassword_list(mail)) == len_before + 1
         api.deauth()
 
-    @pytest.mark.depends(name=["test_mail_add"])
+    @pytest.mark.depends(name="test_mail_add")
     def test_mail_apppassword_list(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -428,9 +470,9 @@ class TestAPIClient:
         assert len(api.mail_apppassword_list(mail)) > 0
         api.deauth()
 
-    @pytest.mark.depends(name=["test_mail_add"])
-    @pytest.mark.depends(name=['test_mail_apppassword_add'])
-    @pytest.mark.depends(name=['test_mail_apppassword_list'])
+    @pytest.mark.depends(name="test_mail_add")
+    @pytest.mark.depends(name='test_mail_apppassword_add')
+    @pytest.mark.depends(name='test_mail_apppassword_list')
     def test_mail_apppassword_del(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -445,8 +487,9 @@ class TestAPIClient:
 
         # After deleting all app passwords, length should be 0
         assert len(api.mail_apppassword_list(mail)) == 0
+        api.deauth()
 
-    @pytest.mark.depends(name=['test_mail_add'])
+    @pytest.mark.depends(name='test_mail_add')
     def test_mail_set_deletion_date(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -457,7 +500,47 @@ class TestAPIClient:
         assert deletion_date in api.mail_get(mail)['deletion_date']
         api.deauth()
 
-    @pytest.mark.depends(name=['test_mail_add'])
+    def test_additionalmailaccount_list(self):
+        api = APIClient.APIClient()
+        api.auth(api_test_user, api_test_pass)
+        parent = 'parent@testbmboapi.internal'
+        sub = 'sub_mail@testbmboapi.internal'
+        assert sub in api.additionalmailaccount_list(parent)['additional_accounts']
+        api.deauth()
+
+    # Removed test as the API is too unrealiable.
+    # It oftentimes needs too much time to update and reply with the updated data for the test to work reliably
+    # def test_additionalmailaccount_add(self):
+    #     api = APIClient.APIClient()
+    #     api.auth(api_test_user, api_test_pass)
+    #     parent_mail = test_id + '_parent@' + domain
+    #     sub_mail = test_id + '_sub@' + domain
+    #     pw = generate_pw()
+    #     # Creating the accounts
+    #     api.mail_add(parent_mail, pw, 'light', 'test parent', 'test_parent')
+    #     api.mail_add(sub_mail, pw, 'light', 'test sub', 'test_sub' )
+    #     # Adding it to the mail account
+    #     assert api.additionalmailaccount_add(parent_mail, sub_mail, pw) == True
+    #     # Before checking the result, wait for a bit
+    #     # The mailbox API is sometimes slower than the test, resulting in failed tests
+    #     time.sleep(5)
+    #     # Checking that the sub account is listed as an additional account
+    #     assert sub_mail in api.additionalmailaccount_list(parent_mail)['additional_accounts']
+    #     api.deauth()
+
+    # @pytest.mark.depends(name='test_additionalmailaccount_add')
+    # def test_additionalmailaccount_delete(self):
+    #     api = APIClient.APIClient()
+    #     api.auth(api_test_user, api_test_pass)
+    #     parent_mail = test_id + '_parent@' + domain
+    #     sub_mail = test_id + '_sub@' + domain
+    #     assert api.additionalmailaccount_delete(parent_mail, sub_mail) == True
+    #     assert sub_mail not in api.additionalmailaccount_list(parent_mail)
+    #     api.mail_del(parent_mail)
+    #     api.mail_del(sub_mail)
+    #     api.deauth()
+
+    @pytest.mark.depends(name='test_mail_add')
     def test_search(self):
         api = APIClient.APIClient()
         api.auth(api_test_user, api_test_pass)
@@ -465,6 +548,7 @@ class TestAPIClient:
         assert mail in api.search(mail)['emails']
         assert domain in api.search(domain)['domains']
         assert api_test_user in api.search(api_test_user)['accounts']
+        api.deauth()
 
     @pytest.mark.order('last')
     def test_mail_del(self):