Saimon/refactor ut (#288)

Author: saimonation

cterasdk/asynchronous/core/notifications.py

@@ -32,6 +32,7 @@ async def get(self, cloudfolders=None, cursor=None, max_results=None):
         param.max_results = max_results if max_results is not None else 2000
         logging.getLogger('cterasdk.metadata.connector').debug('Listing updates.')
         response = await self._core.v2.api.post('/metadata/list', param)
+        print(response)
         if response is not None:
             return CursorResponse(response)
         logging.getLogger('cterasdk.metadata.connector').error('An error occurred while trying to retrieve notifications.')
@@ -197,13 +198,13 @@ async def persist_cursor(save_cursor, cursor):
     :param callback save_cursor: Asynchronous callback function to persist the cursor.
     :param str cursor: Cursor
     """
-    logging.getLogger('cterasdk.metadata.connector').debug("Persisting Cursor. Calling function: '%s'", save_cursor.__name__)
+    logging.getLogger('cterasdk.metadata.connector').debug("Persisting Cursor. Calling function: '%s'", save_cursor)
     try:
         await save_cursor(cursor)
         logging.getLogger('cterasdk.metadata.connector').debug("Called Persist Cursor Function.")
     except Exception:  # pylint: disable=broad-exception-caught
         logging.getLogger('cterasdk.metadata.connector').error("An error occurred while trying to persist cursor. Function: '%s'",
-                                                               save_cursor.__name__)
+                                                               save_cursor)
 
 
 async def on_connection_error(error):

docs/source/UserGuides/Portal/Administration.rst

@@ -1573,7 +1573,7 @@ Timezone
 
 .. code:: python
 
-   admin.settings.global_settings.set_timzeone('(GMT-05:00) Eastern Time (US , Canada)')
+   admin.settings.global_settings.set_timezone('(GMT-05:00) Eastern Time (US , Canada)')
 
 
 Virtual Portal Settings

tests/ut/aio/__init__.py

@@ -0,0 +1,15 @@
+import unittest
+from ..common import utilities
+
+
+class BaseAsyncTest(unittest.IsolatedAsyncioTestCase):
+    """Base Async Test"""
+
+    def patch_call(self, module_path, **patch_kwargs):
+        return utilities.patch_call(self, module_path, **patch_kwargs)
+
+    def patch_property(self, module_path, **patch_kwargs):
+        return utilities.patch_property(self, module_path, **patch_kwargs)
+
+    def assert_equal_objects(self, actual_param, expected_param):
+        return utilities.assert_equal_objects(self, actual_param, expected_param)

tests/ut/aio/base.py

@@ -0,0 +1,16 @@
+from unittest import mock
+
+from cterasdk.objects import AsyncGlobalAdmin
+from tests.ut.aio import base
+
+
+class BaseAsyncCoreTest(base.BaseAsyncTest):
+
+    def setUp(self):
+        super().setUp()
+        self._global_admin = AsyncGlobalAdmin("")
+
+    def _init_global_admin(self, get_multi_response=None, form_data_response=None, post_response=None):
+        self._global_admin.v1.api.get_multi = mock.AsyncMock(return_value=get_multi_response)
+        self._global_admin.v1.api.form_data = mock.AsyncMock(return_value=form_data_response)
+        self._global_admin.v2.api.post = mock.AsyncMock(return_value=post_response)

tests/ut/aio/base_core.py

@@ -0,0 +1,13 @@
+from unittest import mock
+from cterasdk import ctera_direct
+from .. import base
+
+
+class BaseAsyncDirect(base.BaseAsyncTest):
+
+    def setUp(self, access=None, secret=None):
+        super().setUp()
+        self._direct = ctera_direct.client.DirectIO('', access, secret)
+        self._direct._client._api.get = mock.AsyncMock()  # pylint: disable=protected-access
+        self._direct._client._client.get = mock.AsyncMock()  # pylint: disable=protected-access
+        self._authorization_header = {'Authorization': f'Bearer {access}'}

tests/ut/aio/direct/__init__.py

@@ -0,0 +1,102 @@
+import asyncio
+import errno
+from unittest import mock
+import munch
+from cterasdk import ctera_direct
+from cterasdk import exceptions, Object
+from . import base
+
+
+class BaseDirectMetadata(base.BaseAsyncDirect):
+
+    def setUp(self):  # pylint: disable=arguments-differ
+        super().setUp()
+        self._retries = 3
+        self._file_id = 12345
+
+    async def test_retries_on_error(self):
+        self._direct._client._api.get.return_value = munch.Munch({'chunks': None})  # pylint: disable=protected-access
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.BlocksNotFoundError):
+                await self._direct.metadata(self._file_id)
+        self._direct._client._api.get.assert_has_calls(  # pylint: disable=protected-access
+            self._retries * [
+                mock.call(f'{self._file_id}', headers=self._authorization_header),
+            ]
+        )
+
+    async def test_get_file_metadata_not_found(self):
+        self._direct._client._api.get.return_value = munch.Munch({'chunks': None})  # pylint: disable=protected-access
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.BlocksNotFoundError) as error:
+                await self._direct.metadata(self._file_id)
+        self.assertEqual(error.exception.errno, errno.ENODATA)
+        self.assertEqual(error.exception.strerror, 'Blocks not found')
+        self.assertEqual(error.exception.filename, self._file_id)
+
+    async def test_get_file_metadata_error_400(self):
+        self._direct._client._api.get.side_effect = exceptions.ClientResponseException(  # pylint: disable=protected-access
+            BaseDirectMetadata._create_error_object(400)
+        )
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.NotFoundError) as error:
+                await self._direct.metadata(self._file_id)
+        self.assertEqual(error.exception.errno, errno.EBADF)
+        self.assertEqual(error.exception.strerror, 'File not found')
+        self.assertEqual(error.exception.filename, self._file_id)
+
+    async def test_get_file_metadata_error_401(self):
+        self._direct._client._api.get.side_effect = exceptions.ClientResponseException(  # pylint: disable=protected-access
+            BaseDirectMetadata._create_error_object(401)
+        )
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.UnAuthorized) as error:
+                await self._direct.metadata(self._file_id)
+        self.assertEqual(error.exception.errno, errno.EACCES)
+        self.assertEqual(error.exception.strerror, 'Unauthorized: You do not have the necessary permissions to access this resource')
+        self.assertEqual(error.exception.filename, self._file_id)
+
+    async def test_get_file_metadata_error_422(self):
+        self._direct._client._api.get.side_effect = exceptions.ClientResponseException(  # pylint: disable=protected-access
+            BaseDirectMetadata._create_error_object(422)
+        )
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.UnprocessableContent) as error:
+                await self._direct.metadata(self._file_id)
+        self.assertEqual(error.exception.errno, errno.ENOTSUP)
+        self.assertEqual(error.exception.strerror, 'Not all blocks of the requested file are stored on a storage node set to Direct Mode')
+        self.assertEqual(error.exception.filename, self._file_id)
+
+    async def test_get_file_metadata_unknown_error(self):
+        self._direct._client._api.get.side_effect = exceptions.ClientResponseException(  # pylint: disable=protected-access
+            BaseDirectMetadata._create_error_object(500)
+        )
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(exceptions.ClientResponseException) as error:
+                await self._direct.metadata(self._file_id)
+        self.assertEqual(error.exception.message, 'An error occurred while processing the HTTP request.')
+
+    async def test_get_file_metadata_connection_error(self):
+        self._direct._client._api.get.side_effect = ConnectionError  # pylint: disable=protected-access
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.BlockListConnectionError) as error:
+                await self._direct.metadata(self._file_id)
+        self.assertEqual(error.exception.errno, errno.ENETRESET)
+        self.assertEqual(error.exception.strerror, 'Failed to list blocks. Connection error')
+        self.assertEqual(error.exception.filename, self._file_id)
+
+    async def test_get_file_metadata_timeout(self):
+        self._direct._client._api.get.side_effect = asyncio.TimeoutError  # pylint: disable=protected-access
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.BlockListTimeout) as error:
+                await self._direct.metadata(self._file_id)
+        self.assertEqual(error.exception.errno, errno.ETIMEDOUT)
+        self.assertEqual(error.exception.strerror, 'Failed to list blocks. Timed out')
+        self.assertEqual(error.exception.filename, self._file_id)
+
+    @staticmethod
+    def _create_error_object(status):
+        param = Object()
+        param.response = Object()
+        param.response.status = status
+        return param

tests/ut/aio/direct/base.py

@@ -0,0 +1,91 @@
+import asyncio
+import errno
+from unittest import mock
+import munch
+from cterasdk.direct.lib import get_object
+from cterasdk import exceptions, ctera_direct, Object
+from . import base
+
+
+class BaseDirectMetadata(base.BaseAsyncDirect):
+
+    def setUp(self):  # pylint: disable=arguments-differ
+        super().setUp()
+        self._retries = 3
+        self._file_id = 12345
+
+    async def test_get_object_connection_error(self):
+        chunk = BaseDirectMetadata._create_chunk()
+        self._direct._client._client.get.side_effect = ConnectionError  # pylint: disable=protected-access
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.DownloadConnectionError) as error:
+                await get_object(self._direct._client._client, self._file_id, chunk)  # pylint: disable=protected-access
+        self.assertEqual(error.exception.errno, errno.ENETRESET)
+        self.assertEqual(error.exception.strerror, 'Failed to download block. Connection error')
+        self.assertEqual(error.exception.filename, self._file_id)
+        self.assert_equal_objects(error.exception.block, BaseDirectMetadata._create_block_info(self._file_id, chunk))
+
+    async def test_get_object_timeout(self):
+        chunk = BaseDirectMetadata._create_chunk()
+        self._direct._client._client.get.side_effect = asyncio.TimeoutError  # pylint: disable=protected-access
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.DownloadTimeout) as error:
+                await get_object(self._direct._client._client, self._file_id, chunk)  # pylint: disable=protected-access
+        self.assertEqual(error.exception.errno, errno.ETIMEDOUT)
+        self.assertEqual(error.exception.strerror, 'Failed to download block. Timed out')
+        self.assertEqual(error.exception.filename, self._file_id)
+        self.assert_equal_objects(error.exception.block, BaseDirectMetadata._create_block_info(self._file_id, chunk))
+
+    async def test_response_read_io_error(self):
+        message = 'Error reading block.'
+        chunk = BaseDirectMetadata._create_chunk()
+
+        async def stream_reader():
+            raise IOError(message)
+
+        self._direct._client._client.get.return_value = munch.Munch({'read': stream_reader})  # pylint: disable=protected-access
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.DownloadError) as error:
+                await get_object(self._direct._client._client, self._file_id, chunk)  # pylint: disable=protected-access
+        self.assertEqual(error.exception.errno, errno.EIO)
+        self.assertEqual(str(error.exception.strerror), message)
+        self.assertEqual(error.exception.filename, self._file_id)
+        self.assert_equal_objects(error.exception.block, BaseDirectMetadata._create_block_info(self._file_id, chunk))
+
+    async def test_get_client_error(self):
+        chunk = BaseDirectMetadata._create_chunk()
+        self._direct._client._client.get.side_effect = exceptions.ClientResponseException(  # pylint: disable=protected-access
+            self._create_error_object(500)
+        )
+        with mock.patch('asyncio.sleep'):
+            with self.assertRaises(ctera_direct.exceptions.DownloadError) as error:
+                await get_object(self._direct._client._client, self._file_id, chunk)  # pylint: disable=protected-access
+        self.assertEqual(error.exception.errno, errno.EIO)
+        self.assertEqual(error.exception.strerror.status, 500)
+        self.assertEqual(error.exception.filename, self._file_id)
+        self.assert_equal_objects(error.exception.block, BaseDirectMetadata._create_block_info(self._file_id, chunk))
+
+    @staticmethod
+    def _create_error_object(status):
+        param = Object()
+        param.response = Object()
+        param.response.status = status
+        return param
+
+    @staticmethod
+    def _create_block_info(file_id, chunk):
+        return munch.Munch({
+            'file_id': file_id,
+            'number': chunk.index,
+            'offset': chunk.offset,
+            'length': chunk.length
+        })
+
+    @staticmethod
+    def _create_chunk():
+        return munch.Munch({
+            'url': 'https://s3.amazonaws.com/test',
+            'index': 1,
+            'offset': 0,
+            'length': 4096
+        })

tests/ut/aio/direct/test_get_metadata.py

@@ -0,0 +1,25 @@
+from unittest import mock
+import munch
+from cterasdk.asynchronous.core import cloudfs
+from cterasdk.core.query import QueryParamBuilder, FilterBuilder
+from tests.ut.aio import base_core
+
+
+class TestAsyncCoreUsers(base_core.BaseAsyncCoreTest):
+
+    def setUp(self):
+        super().setUp()
+        self._user_id = 56
+        self._name = 'My Files'
+        self._owner = 'owner'
+
+    async def test_find(self):
+        self._global_admin.users.get = mock.AsyncMock(return_value=munch.Munch({'uid': self._user_id}))
+        builder = QueryParamBuilder().include(cloudfs.CloudDrives.default).ownedBy(self._user_id)
+        builder.addFilter(FilterBuilder('name').eq(self._name))
+        expected_param = builder.build()
+        with mock.patch("cterasdk.asynchronous.core.cloudfs.query.iterator") as query_iterator_mock:
+            await cloudfs.CloudDrives(self._global_admin).find(self._name, self._owner)
+        self._global_admin.users.get.assert_called_once_with(self._owner, ['uid'])
+        query_iterator_mock.assert_called_once_with(self._global_admin, '/cloudDrives', mock.ANY)
+        self.assert_equal_objects(query_iterator_mock.call_args[0][2], expected_param)

tests/ut/aio/direct/test_get_object.py

@@ -0,0 +1,57 @@
+from unittest import mock
+from cterasdk.common import Object
+from cterasdk import exceptions
+from tests.ut.aio import base_core
+
+
+class TestAsyncCoreLogin(base_core.BaseAsyncCoreTest):
+
+    _tenant = 'ctera'
+    _username = 'username'
+    _password = 'password'
+    _version = '7.5.182.16'
+
+    def setUp(self):
+        super().setUp()
+        self._tenant = TestAsyncCoreLogin._tenant
+        self._username = TestAsyncCoreLogin._username
+        self._password = TestAsyncCoreLogin._password
+        self._version = TestAsyncCoreLogin._version
+
+    async def test_login_success(self):
+        self._init_global_admin()
+        self._global_admin.v1.api.get = mock.AsyncMock(side_effect=TestAsyncCoreLogin._obtain_session_info)
+        await self._global_admin.login(self._username, self._password)
+        self._global_admin.v1.api.form_data.assert_called_once_with('/login', {'j_username': self._username, 'j_password': self._password})
+
+    async def test_login_failure(self):
+        self._init_global_admin()
+        self._global_admin.v1.api.form_data = mock.AsyncMock(side_effect=exceptions.ClientResponseException(Object()))
+        with self.assertRaises(exceptions.CTERAException):
+            await self._global_admin.login(self._username, self._password)
+
+    async def test_logout_success_after_login(self):
+        self._init_global_admin()
+        self._global_admin.v1.api.get = mock.AsyncMock(side_effect=TestAsyncCoreLogin._obtain_session_info)
+        await self._global_admin.login(self._username, self._password)
+        await self._global_admin.logout()
+        self._global_admin.v1.api.form_data.assert_has_calls(
+            [
+                mock.call('/login', {'j_username': self._username, 'j_password': self._password}),
+                mock.call('/logout', {})
+            ]
+        )
+
+    @staticmethod
+    def _obtain_session_info(path):
+        if path == '/currentPortal':
+            return TestAsyncCoreLogin._tenant
+        if path == '/version':
+            return TestAsyncCoreLogin._version
+        if path == '/currentSession':
+            current_session = Object()
+            current_session.username = TestAsyncCoreLogin._username
+            current_session.role = TestAsyncCoreLogin._password
+            current_session.domain = None
+            return current_session
+        return ''