def setUp(self) -> None:
self.middlewares = ConfigBuilder.build_from(
TEST_MIDDLEWARES_CONFIG_PATH).get('middlewares')
self.session_storage = Storage()
self.server_storage = Storage()
self.global_storage = Storage()
class TestInfiniteLoopBuilder(TestCase):
def setUp(self) -> None:
self.middlewares = ConfigBuilder.build_from(
TEST_MIDDLEWARES_CONFIG_PATH).get('middlewares')
self.session_storage = Storage()
self.server_storage = Storage()
self.global_storage = Storage()
def test_infinite_loop_building(self):
infinite_loop: partial = InfiniteLoopBuilder.build_from(
self.middlewares.get('only_infinite_loop'))
self.assertEqual(infinite_loop.func.__name__, 'infinite_loop')
@async_test
async def test_infinite_loop_processing(self):
infinite_loop: partial = InfiniteLoopBuilder.build_from(
self.middlewares.get('only_infinite_loop'))
middlewares_amount = len(
self.middlewares.get('only_infinite_loop')[0].args[0].args[0])
iterations_amount = (
ITERATIONS_LIMIT // middlewares_amount +
(1 if ITERATIONS_LIMIT % middlewares_amount else 0))
self.session_storage.set_items([{
'break_after': {
'value': ITERATIONS_LIMIT,
'flags': ItemFlag.PERSISTENT
}
}])
await infinite_loop(session_storage=self.session_storage,
server_storage=self.server_storage,
global_storage=self.global_storage)
self.assertEqual(
self.session_storage, {
'break_after': {
'value': ITERATIONS_LIMIT,
'flags': ItemFlag.PERSISTENT
},
'mock_value': {
'value': middlewares_amount * iterations_amount,
'flags': ItemFlag.PERSISTENT
},
'should_break': {
'value': True,
'flags': ItemFlag.PERSISTENT
}
})
class TestPipeBuilder(TestCase):
def setUp(self) -> None:
self.middlewares = ConfigBuilder.build_from(
TEST_MIDDLEWARES_CONFIG_PATH).get('middlewares')
self.session_storage = Storage()
self.server_storage = Storage()
self.global_storage = Storage()
def test_pipe_building(self):
pipe: partial = PipeBuilder.build_from(self.middlewares.get('only_fn'))
self.assertEqual(pipe.func.__name__, 'pipe')
@async_test
async def test_pipe_processing(self):
pipe: partial = PipeBuilder.build_from(self.middlewares.get('only_fn'))
await pipe(session_storage=self.session_storage,
server_storage=self.server_storage,
global_storage=self.global_storage)
self.assertEqual(
self.session_storage,
{'mock_value': {
'value': 2,
'flags': ItemFlag.PERSISTENT
}})
self.assertEqual(self.session_storage.get_value('mock_value'), 2)
def _init_session_storage(self, *args, **kwargs) -> Storage:
sender = args[0] if args else kwargs.pop('sender')
return Storage(is_debug=self.is_debug,
debug_name=f'Session Storage | '
f'{self.server_name} | '
f'{sender}')
async def test_function_processing(self):
function: Callable = FunctionBuilder.build_from(TEST_MIDDLEWARE_PATH)
session_storage = Storage()
await function(session_storage=session_storage)
self.assertEqual(
session_storage,
{
'mock_value': {
'value': 1,
'flags': ItemFlag.PERSISTENT
}
}
)
def __init__(self, **kwargs):
# connection
self.host: str = kwargs.pop('host')
self.port: int = kwargs.pop('port')
self.connection_type: str = kwargs.pop('connection_type')
# proxy
self.proxy: Optional[BaseProxy] = kwargs.pop('proxy', None)
# server options
self.server_name: str = kwargs.pop('server_name')
self.is_debug: bool = kwargs.pop('is_debug')
# middlewares
self.middlewares_entry: Callable = kwargs.pop('middlewares_entry')
# storages
self.global_storage: Storage = kwargs.pop('global_storage')
self.server_storage: Storage = Storage(
is_debug=self.is_debug,
debug_name=f'Server Storage | {self.server_name}',
)
self._instance: Optional[Generator] = None
class TestRouterBuilder(TestCase):
def setUp(self) -> None:
self.middlewares = ConfigBuilder.build_from(
TEST_MIDDLEWARES_CONFIG_PATH).get('middlewares')
self.session_storage = Storage()
self.server_storage = Storage()
self.global_storage = Storage()
def test_infinite_loop_building(self):
router: partial = RouterBuilder.build_from(
self.middlewares.get('only_router'))
self.assertEqual(router.func.__name__, 'router')
@async_test
async def test_inline_route_processing(self):
router: partial = RouterBuilder.build_from(
self.middlewares.get('only_router'))
self.session_storage.set_items([{
'route': {
'value': 'TEST_ROUTE_INLINE'
}
}])
await router(session_storage=self.session_storage,
server_storage=self.server_storage,
global_storage=self.global_storage)
self.assertEqual(
self.session_storage,
{'mock_value': {
'value': 1,
'flags': ItemFlag.PERSISTENT
}})
@async_test
async def test_unexpected_route(self):
router: partial = RouterBuilder.build_from(
self.middlewares.get('only_router'))
self.session_storage.set_items([{
'route': {
'value': 'NOT_EXISTED_ROUTE'
}
}])
with self.assertRaises(ValueError) as context:
await router(session_storage=self.session_storage,
server_storage=self.server_storage,
global_storage=self.global_storage)
self.assertTrue(isinstance(context.exception, ValueError))
self.assertTrue('Unexpected route' in context.exception.args[0])
@async_test
async def test_list_route_processing(self):
router: partial = RouterBuilder.build_from(
self.middlewares.get('only_router'))
self.session_storage.set_items([{
'route': {
'value': 'TEST_ROUTE_LIST'
}
}])
await router(session_storage=self.session_storage,
server_storage=self.server_storage,
global_storage=self.global_storage)
self.assertEqual(
self.session_storage,
{'mock_value': {
'value': 3,
'flags': ItemFlag.PERSISTENT
}})
def setUp(self) -> None:
self.storage = Storage()
class TestStorage(TestCase):
def setUp(self) -> None:
self.storage = Storage()
def test_set_and_get_item(self):
self.storage.set_items([{TEST_KEY: {'value': TEST_VALUE}}])
self.assertEqual(self.storage.get_value(TEST_KEY), TEST_VALUE)
def test_clean_temporary_fields(self):
self.storage.set_items([{TEST_KEY: {'value': TEST_VALUE}}])
self.storage.clean_temporary_fields()
self.assertIsNone(self.storage.get_value(TEST_KEY))
def test_not_clean_persistent_fields(self):
self.storage.set_items([{
TEST_KEY: {
'value': TEST_VALUE,
'flags': ItemFlag.PERSISTENT
}
}])
self.storage.clean_temporary_fields()
self.assertIsNotNone(self.storage.get_value(TEST_KEY))
self.assertEqual(self.storage.get_value(TEST_KEY), TEST_VALUE)
def test_cannot_change_frozen_field(self):
self.storage.set_items([{
TEST_KEY: {
'value': TEST_VALUE,
'flags': ItemFlag.FROZEN
}
}])
with self.assertRaises(OverwriteFrozenFieldError):
self.storage._set_item(TEST_KEY, TEST_ANOTHER_VALUE)
self.assertEqual(self.storage.get_value(TEST_KEY), TEST_VALUE)
def test_get_non_existent_value(self):
self.assertIsNone(self.storage.get_value(TEST_NON_EXISTENT_KEY))