Python AsyncCacheManager Exemples

Exemple #1

async def test_builder_aioredis_create_destory(event_loop):
    cache_manger = AsyncCacheManager(
        None,
        cache_backend="AIORedisBackend",
        config={
            "CACHE_REDIS_SCHEME": "redis",
            "CACHE_REDIS_HOST": "192.168.201.169",
            "CACHE_REDIS_PORT": 6379,
            "CACHE_REDIS_PASSWORD": "",
            "CACHE_REDIS_DATABASE": 8,
            'CACHE_REDIS_CONNECTION_TIMEOUT': 3,
            'CACHE_REDIS_ENCODING': 'utf-8',
            'CACHE_REDIS_USE_POOL': True,
            'CACHE_REDIS_POOL_MINSIZE': 1,  # no effect
            'CACHE_REDIS_POOL_MAXSIZE': 50,
            'CACHE_REDIS_USE_CLUSTER': False,  # for cluster not tested
            'CACHE_REDIS_MAX_IDLE_TIME': 0,
            'CACHE_REDIS_RETRY_ON_TIMEOUT': False,
            'CACHE_REDIS_IDLE_CHECK_INTERVAL': 1,
            "CACHE_KEY_PREFIX": "A_REDIS_MANAGER_UNIT_TEST_POOL:"
        })
    assert isinstance(cache_manger.cache_backend, AIORedisBackend)

    val = await cache_manger.get("foo")
    assert val is None

    cache_context = cache_manger.handle_backend_cache_context()
    assert isinstance(cache_context, AIORedisContext)

    await cache_manger.destroy_backend_cache_context()

Exemple #2

def test_builder_error(setup_module):
    try:
        cache_manger = AsyncCacheManager(
            None,
            cache_backend="null_cache",
            config=tuple(["key", "val"]),
        )
    except Exception as ex:
        assert isinstance(ex, ValueError)
    try:
        cache_manger = AsyncCacheManager(
            None,
            cache_backend="simple_cache",
            config=tuple(["key", "val"]),
        )
    except Exception as ex:
        assert isinstance(ex, ValueError)
    try:
        cache_manger = AsyncCacheManager(
            None,
            cache_backend="aioredis",
            config=tuple(["key", "val"]),
        )
    except Exception as ex:
        assert isinstance(ex, ValueError)
    try:
        cache_manger = AsyncCacheManager(
            None,
            cache_backend="aredis",
            config=tuple(["key", "val"]),
        )
    except Exception as ex:
        assert isinstance(ex, ValueError)

Exemple #3

def test_backend_implement_error(setup_module):
    try:
        foo_cache = AsyncCacheManager(None,
                                      cache_backend="foo.bar",
                                      config="some not a dict")
    except Exception as ex:
        assert isinstance(ex, ValueError)
    try:
        foo_cache = AsyncCacheManager(None, cache_backend="foo.bar")
    except Exception as ex:
        assert isinstance(ex, ValueError)

Exemple #4

async def test_builder_aredis_create_destory(event_loop):
    cache_manger = AsyncCacheManager(
        None,
        cache_backend="omi_cache_manager.aio_redis_backend.AIORedisBackend",
        config={"CACHE_KEY_PREFIX": "AIO_REDIS_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, AIORedisBackend)

    await cache_manger.destroy_backend_cache_context()

    cache_context = cache_manger.handle_backend_cache_context()
    assert cache_context is None

Exemple #5

async def test_builder_simple_create_destory(event_loop):
    cache_manger = AsyncCacheManager(
        None,
        cache_backend="simple_cache",
        config={"CACHE_KEY_PREFIX": "SIMPLE_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, SimpleCacheBackend)

    val = await cache_manger.get("foo")
    assert val is None

    cache_context = cache_manger.handle_backend_cache_context()
    assert isinstance(cache_context, SimpleCacheDictContext)

    await cache_manger.destroy_backend_cache_context()

Exemple #6

Fichier : test_unit_omi_cache_simple_backend.py Projet : qw2536807/omi_cache_manager

async def test_backend_null(event_loop):
    nullcache = AsyncCacheManager(
        None,
        cache_backend=NullCacheBackend(config={}),
        config={}
    )

    val = await nullcache.set("foo", "bar")
    assert val is True
    val = await nullcache.get("foo")
    assert val is None
    val = await nullcache.set_many("foo1", "bar1", "foo2", "bar2")
    assert val is True
    val = await nullcache.get_many("foo1", "foo2")
    assert val is None
    val = await nullcache.add("foo", "bar")
    assert val is True
    val = await nullcache.delete("foo")
    assert val is True
    val = await nullcache.delete_many("foo")
    assert val is True
    val = await nullcache.execute("GET", "foo")
    assert val is None
    val = await nullcache.clear()
    assert val is None

Exemple #7

def test_builder_aioredis(setup_module):
    cache_manger = AsyncCacheManager(
        None,
        cache_backend="omi_cache_manager.aio_redis_backend.AIORedisBackend",
        config={"CACHE_KEY_PREFIX": "AIO_REDIS_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, AIORedisBackend)

    cache_manger = AsyncCacheManager(
        None,
        cache_backend="aioredis",
        config={"CACHE_KEY_PREFIX": "AIO_REDIS_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, AIORedisBackend)

    cache_manger = AsyncCacheManager(
        None,
        cache_backend="AIORedisBackend",
        config={"CACHE_KEY_PREFIX": "AIO_REDIS_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, AIORedisBackend)

Exemple #8

def test_builder_null(setup_module):
    cache_manger = AsyncCacheManager(
        None,
        cache_backend="omi_cache_manager.backends.NullCacheBackend",
        config={"CACHE_KEY_PREFIX": "NULL_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, NullCacheBackend)

    cache_manger = AsyncCacheManager(
        None,
        cache_backend="null_cache",
        config={"CACHE_KEY_PREFIX": "NULL_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, NullCacheBackend)

    cache_manger = AsyncCacheManager(
        None,
        cache_backend="NullCacheBackend",
        config={"CACHE_KEY_PREFIX": "NULL_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, NullCacheBackend)

Exemple #9

def test_builder_simple(setup_module):
    cache_manger = AsyncCacheManager(
        None,
        cache_backend="omi_cache_manager.backends.SimpleCacheBackend",
        config={"CACHE_KEY_PREFIX": "SIMPLE_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, SimpleCacheBackend)

    cache_manger = AsyncCacheManager(
        None,
        cache_backend="simple_cache",
        config={"CACHE_KEY_PREFIX": "SIMPLE_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, SimpleCacheBackend)

    cache_manger = AsyncCacheManager(
        None,
        cache_backend="SimpleCacheBackend",
        config={"CACHE_KEY_PREFIX": "SIMPLE_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, SimpleCacheBackend)

Exemple #10

async def test_builder_null_create_destory(event_loop):
    cache_manger = AsyncCacheManager(
        None,
        cache_backend="null_cache",
        config={"CACHE_KEY_PREFIX": "NULL_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.cache_backend, NullCacheBackend)

    val = await cache_manger.get("foo")
    assert val is None

    cache_context = cache_manger.handle_backend_cache_context()
    assert cache_context is None

    create_result = cache_manger.create_backend_cache_context()
    assert create_result is None

    cache_context = cache_manger.handle_backend_cache_context()
    assert cache_context is None

    await cache_manger.destroy_backend_cache_context()

Exemple #11

async def test_builder_bind_app(event_loop):
    test_app = MockContext()
    setattr(test_app, "state", None)
    cache_manger = AsyncCacheManager(
        test_app,
        cache_backend="omi_cache_manager.aio_redis_backend.AIORedisBackend",
        config={"CACHE_KEY_PREFIX": "AIO_REDIS_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.app_ref, MockContext)

    test_app = MockContext()
    setattr(test_app, "state", MockContext())
    cache_manger = AsyncCacheManager(
        test_app,
        cache_backend="omi_cache_manager.aio_redis_backend.AIORedisBackend",
        config={"CACHE_KEY_PREFIX": "AIO_REDIS_MANAGER_UNIT_TEST_POOL:"})
    assert isinstance(cache_manger.app_ref, MockContext)
    assert isinstance(cache_manger.app_ref.state, MockContext)
    assert isinstance(cache_manger.app_ref.state.OMI_CACHE_MANAGER,
                      AsyncCacheManager)

    # bind twice cause error
    try:
        cache_manger = AsyncCacheManager(
            test_app,
            cache_backend="omi_cache_manager.aio_redis_backend.AIORedisBackend",
            config={"CACHE_KEY_PREFIX": "AIO_REDIS_MANAGER_UNIT_TEST_POOL:"})
    except Exception as ex:
        assert isinstance(ex, ValueError)

    test_app = MockContext()
    test_app.state = MockContext()
    test_app.state.OMI_CACHE_MANAGER = MockContext()

    # bind before set to AsyncCacheManager
    try:
        cache_manger = AsyncCacheManager(
            test_app,
            cache_backend="omi_cache_manager.aio_redis_backend.AIORedisBackend",
            config={"CACHE_KEY_PREFIX": "AIO_REDIS_MANAGER_UNIT_TEST_POOL:"})
    except Exception as ex:
        assert isinstance(ex, ValueError)

Exemple #12

Fichier : test_unit_omi_cache_manager_aredis_backend.py Projet : qw2536807/omi_cache_manager

# RuntimeError: This event loop is already running
# pip install nest_asyncio
import nest_asyncio

nest_asyncio.apply()
# =======================================

aredis_cache = AsyncCacheManager(
    None,
    cache_backend="omi_cache_manager.aredis_backend.ARedisBackend",
    config={
        "CACHE_REDIS_SCHEME": "redis",
        "CACHE_REDIS_HOST": "192.168.201.169",
        "CACHE_REDIS_PORT": 6379,
        "CACHE_REDIS_USER": "******",
        "CACHE_REDIS_PASSWORD": "",
        "CACHE_REDIS_DATABASE": 8,
        'CACHE_REDIS_CONNECTION_TIMEOUT': 3,
        'CACHE_REDIS_ENCODING': 'utf-8',
        'CACHE_REDIS_USE_CLUSTER': False,  # for cluster not tested
        'CACHE_REDIS_USE_POOL': False,
        'CACHE_REDIS_POOL_MINSIZE': 1,  # no effect
        'CACHE_REDIS_POOL_MAXSIZE': 50,
        "CACHE_KEY_PREFIX": "A_REDIS_MANAGER_UNIT_TEST:"
    })

aredis_cache_use_pool = AsyncCacheManager(
    None,
    cache_backend="omi_cache_manager.aredis_backend.ARedisBackend",
    config={
        "CACHE_REDIS_SCHEME": "redis",
        "CACHE_REDIS_HOST": "192.168.201.169",

Exemple #13

Fichier : test_unit_omi_cache_manager_aio_redis_backend.py Projet : qw2536807/omi_cache_manager

import nest_asyncio

nest_asyncio.apply()
# =======================================

aioredis_cache = AsyncCacheManager(
    None,
    cache_backend="omi_cache_manager.aio_redis_backend.AIORedisBackend",
    config={
        "CACHE_REDIS_SCHEME": "redis",
        "CACHE_REDIS_HOST": "192.168.201.169",
        "CACHE_REDIS_PORT": "6379",
        "CACHE_REDIS_USER": "******",
        "CACHE_REDIS_PASSWORD": "",
        "CACHE_REDIS_DATABASE": 8,

        'CACHE_REDIS_CONNECTION_TIMEOUT': True,
        'CACHE_REDIS_DECODE_RESPONSE': 3,
        'CACHE_REDIS_ENCODING': 'utf-8',

        'CACHE_REDIS_USE_POOL': False,
        'CACHE_REDIS_POOL_MINSIZE': 1,
        'CACHE_REDIS_POOL_MAXSIZE': 50,

        "CACHE_KEY_PREFIX": "AIO_REDIS_MANAGER_UNIT_TEST:"
    }
)

aioredis_cache_use_pool = AsyncCacheManager(
    None,
    cache_backend="omi_cache_manager.aio_redis_backend.AIORedisBackend",
    config={

Exemple #14

def test_backend_implement(setup_module):
    simple_cache = AsyncCacheManager(
        None, cache_backend=SimpleCacheBackend(config={}))

Exemple #15

from omi_cache_manager.async_cache_manager import AsyncCacheManager
from omi_cache_manager.backends import NullCacheBackend, SimpleCacheBackend

# =======================================
# install nest_asyncio for unit test when
# RuntimeError: This event loop is already running
# pip install nest_asyncio
import nest_asyncio

nest_asyncio.apply()
# =======================================

simple_cache_backend = SimpleCacheBackend(config={})

simple_cache_manager = AsyncCacheManager(
    None,
    cache_backend="omi_cache_manager.backends.SimpleCacheBackend",
    config={"CACHE_KEY_PREFIX": "SOME_PREFIX:"})

simple_cache_from_instance = AsyncCacheManager(
    None,
    cache_backend=SimpleCacheBackend(
        config={"CACHE_KEY_PREFIX": "SOME_PREFIX:"}))


@pytest.fixture(scope='function')
def setup_function(request):
    def teardown_function():
        print("teardown_function called.")

    request.addfinalizer(teardown_function)
    print('setup_function called.')