Python Cache 예제들

예제 #1

파일: test_database.py 프로젝트: lecram/beaker

def test_clear():
    cache = Cache('test', data_dir='./cache', url=db_url, type='ext:database')
    o = object()
    cache.set_value("test", o)
    assert "test" in cache
    cache.clear()
    assert "test" not in cache

예제 #2

파일: test_memcached.py 프로젝트: lecram/beaker

def test_has_key_multicache():
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    o = object()
    cache.set_value("test", o)
    assert "test" in cache
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    assert "test" in cache

예제 #3

    def test_pylibmc_pool_sharing(self):
        from beaker.ext import memcached

        cache_1a = Cache(
            "test_1a",
            data_dir="./cache",
            memcache_module="pylibmc",
            url=mc_url,
            type="ext:memcached",
        )
        cache_1b = Cache(
            "test_1b",
            data_dir="./cache",
            memcache_module="pylibmc",
            url=mc_url,
            type="ext:memcached",
        )
        cache_2 = Cache(
            "test_2",
            data_dir="./cache",
            memcache_module="pylibmc",
            url="127.0.0.1:11212",
            type="ext:memcached",
        )

        assert cache_1a.namespace.pool is cache_1b.namespace.pool
        assert cache_1a.namespace.pool is not cache_2.namespace.pool

예제 #4

파일: test_cache.py 프로젝트: lecram/beaker

def test_has_key_multicache():
    cache = Cache('test', data_dir='./cache', type='dbm')
    o = object()
    cache.set_value("test", o)
    assert "test" in cache
    cache = Cache('test', data_dir='./cache', type='dbm')
    assert "test" in cache

예제 #5

def test_spaces_in_keys():
    cache = Cache("test", data_dir="./cache", url=mc_url, type="ext:memcached")
    cache.set_value("has space", 24)
    assert cache.has_key("has space")
    assert 24 == cache.get_value("has space")
    cache.set_value("hasspace", 42)
    assert cache.has_key("hasspace")
    assert 42 == cache.get_value("hasspace")

예제 #6

파일: test_memcached.py 프로젝트: 01-/beaker

def test_long_unicode_keys():
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    o = object()
    long_str = u_('Очень длинная строка, которая не влезает в сто двадцать восемь байт и поэтому не проходит ограничение в check_key, что очень прискорбно, не правда ли, друзья? Давайте же скорее исправим это досадное недоразумение!')
    cache.set_value(long_str, o)
    assert long_str in cache
    cache.remove_value(long_str)
    assert long_str not in cache

예제 #7

파일: test_couchdb.py 프로젝트: Grant1219/beaker_extensions

def test_unicode_keys():
    cache = Cache('test', url=db_url, type=db_type, database=db_name)
    o = object()
    cache.set_value(u'hiŏ', o)
    assert u'hiŏ' in cache
    assert u'hŏa' not in cache
    cache.remove_value(u'hiŏ')
    assert u'hiŏ' not in cache

예제 #8

파일: test_memcached.py 프로젝트: 01-/beaker

def test_spaces_in_unicode_keys():
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    o = object()
    cache.set_value(u_('hi ŏ'), o)
    assert u_('hi ŏ') in cache
    assert u_('hŏa') not in cache
    cache.remove_value(u_('hi ŏ'))
    assert u_('hi ŏ') not in cache

예제 #9

파일: test_default.py 프로젝트: xonatius/mongodb_beaker

def test_spaces_in_keys():
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb')
    cache.set_value("has space", 24)
    assert cache.has_key("has space")
    assert 24 == cache.get_value("has space")
    cache.set_value("hasspace", 42)
    assert cache.has_key("hasspace")
    assert 42 == cache.get_value("hasspace")

예제 #10

파일: test_sparse.py 프로젝트: BlueDragonX/beaker_mongodb

def test_unicode_keys():
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb', sparse_collection=True)
    o = object()
    cache.set_value(u'hiŏ', o)
    assert u'hiŏ' in cache
    assert u'hŏa' not in cache
    cache.remove_value(u'hiŏ')
    assert u'hiŏ' not in cache

예제 #11

def test_spaces_in_keys():
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    cache.set_value("has space", 24)
    assert cache.has_key("has space")
    assert 24 == cache.get_value("has space")
    cache.set_value("hasspace", 42)
    assert cache.has_key("hasspace")
    assert 42 == cache.get_value("hasspace")

예제 #12

파일: test_cache.py 프로젝트: arianepaola/tg2jython

def test_unicode_keys():    
    cache = Cache('test', data_dir='./cache', type='dbm')
    o = object()
    cache.set_value(u'hiŏ', o)
    assert u'hiŏ' in cache
    assert u'hŏa' not in cache
    cache.remove_value(u'hiŏ')
    assert u'hiŏ' not in cache

예제 #13

파일: base.py 프로젝트: ardeois/beaker

 def test_spaces_in_unicode_keys(self):
     cache = Cache('test', **self.CACHE_ARGS)
     o = object()
     cache.set_value(u_('hi ŏ'), o)
     assert u_('hi ŏ') in cache
     assert u_('hŏa') not in cache
     cache.remove_value(u_('hi ŏ'))
     assert u_('hi ŏ') not in cache

예제 #14

파일: test_memcached.py 프로젝트: C-Pro/beaker

def test_spaces_in_unicode_keys():
    cache = Cache("test", data_dir="./cache", url=mc_url, type="ext:memcached")
    o = object()
    cache.set_value(u"hi ŏ", o)
    assert u"hi ŏ" in cache
    assert u"hŏa" not in cache
    cache.remove_value(u"hi ŏ")
    assert u"hi ŏ" not in cache

예제 #15

파일: test_database.py 프로젝트: rrutia/UW-Assignments

def test_unicode_keys():
    cache = Cache("test", data_dir="./cache", url=db_url, type="ext:database")
    o = object()
    cache.set_value(u"hiŏ", o)
    assert u"hiŏ" in cache
    assert u"hŏa" not in cache
    cache.remove_value(u"hiŏ")
    assert u"hiŏ" not in cache

예제 #16

파일: base.py 프로젝트: xiaohanghang/beaker

 def test_spaces_in_keys(self):
     cache = Cache('test', **self.CACHE_ARGS)
     cache.set_value("has space", 24)
     assert cache.has_key("has space")
     assert 24 == cache.get_value("has space")
     cache.set_value("hasspace", 42)
     assert cache.has_key("hasspace")
     assert 42 == cache.get_value("hasspace")

예제 #17

파일: test_database.py 프로젝트: 01-/beaker

def test_unicode_keys():
    cache = Cache('test', data_dir='./cache', url=db_url, type='ext:database')
    o = object()
    cache.set_value(u_('hiŏ'), o)
    assert u_('hiŏ') in cache
    assert u_('hŏa') not in cache
    cache.remove_value(u_('hiŏ'))
    assert u_('hiŏ') not in cache

예제 #18

파일: test_nopickle.py 프로젝트: SUNET/mongodb_beaker

def test_has_key_multicache():
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb', sparse_collection=True, skip_pickle=True)
    o = object()
    cache.set_value("test", o)
    assert "test" in cache
    assert "test" in cache
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb', sparse_collection=True, skip_pickle=True)
    assert "test" in cache

예제 #19

파일: test_default.py 프로젝트: BlueDragonX/beaker_mongodb

def test_spaces_in_unicode_keys():
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb')
    o = object()
    cache.set_value(u'hi ŏ', o)
    assert u'hi ŏ' in cache
    assert u'hŏa' not in cache
    cache.remove_value(u'hi ŏ')
    assert u'hi ŏ' not in cache

예제 #20

파일: test_memcached.py 프로젝트: lecram/beaker

def test_has_key():
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    o = object()
    cache.set_value("test", o)
    assert "test" in cache
    assert "foo" not in cache
    cache.remove_value("test")
    assert "test" not in cache

예제 #21

파일: test_database.py 프로젝트: maduhu/HDP-hue

def test_has_key_multicache():
    cache = Cache('test', data_dir='./cache', url=db_url, type='ext:database')
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    assert "test" in cache
    cache = Cache('test', data_dir='./cache', url=db_url, type='ext:database')
    assert cache.has_key("test")
    cache.remove_value('test')

예제 #22

파일: test_memcached.py 프로젝트: C-Pro/beaker

def test_long_unicode_keys():
    cache = Cache("test", data_dir="./cache", url=mc_url, type="ext:memcached")
    o = object()
    for i in range(0, 260):
        long_str = u"Ы" * i
        cache.set_value(long_str, o)
        assert long_str in cache
        cache.remove_value(long_str)
        assert long_str not in cache

예제 #23

파일: base.py 프로젝트: isabella232/beaker-1

    def test_expiretime_automatic(self):
        if not self.SUPPORTS_EXPIRATION:
            self.skipTest("NamespaceManager does not support automatic expiration")

        cache = Cache("test", **self.CACHE_ARGS)
        cache.set_value("has space", 24, expiretime=1)
        assert cache.namespace.has_key("has space")
        time.sleep(1.1)
        assert not cache.namespace.has_key("has space")

예제 #24

def test_has_key_multicache():
    cache = Cache('test', url=db_url, type=db_type, database=db_name)
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    assert "test" in cache
    cache = Cache('test', url=db_url, type=db_type, database=db_name)
    assert cache.has_key("test")
    cache.remove_value('test')

예제 #25

파일: base.py 프로젝트: ardeois/beaker

    def test_expiretime_automatic(self):
        if not self.SUPPORTS_EXPIRATION:
            self.skipTest('NamespaceManager does not support automatic expiration')

        cache = Cache('test', **self.CACHE_ARGS)
        cache.set_value("has space", 24, expiretime=1)
        assert cache.namespace.has_key("has space")
        time.sleep(1.1)
        assert not cache.namespace.has_key("has space")

예제 #26

파일: test_memcached.py 프로젝트: lecram/beaker

 def test_client(self):
     cache = Cache('test', data_dir='./cache', url=mc_url, type="ext:memcached", 
                   protocol='binary')
     o = object()
     cache.set_value("test", o)
     assert "test" in cache
     assert "foo" not in cache
     cache.remove_value("test")
     assert "test" not in cache

예제 #27

파일: test_database.py 프로젝트: isabella232/beaker-1

def test_has_key_multicache():
    cache = Cache("test", data_dir="./cache", url=db_url, type="ext:database")
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    assert "test" in cache
    cache = Cache("test", data_dir="./cache", url=db_url, type="ext:database")
    assert cache.has_key("test")
    cache.remove_value("test")

예제 #28

파일: test_default.py 프로젝트: SUNET/mongodb_beaker

def test_has_key():
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb')
    o = object()
    cache.set_value("test", o)
    assert "test" in cache
    assert "test" in cache
    assert "foo" not in cache
    assert "foo" not in cache
    cache.remove_value("test")
    assert "test" not in cache

예제 #29

파일: test_nopickle.py 프로젝트: SUNET/mongodb_beaker

 def test_client(self):
     cache = Cache('test', data_dir='./cache', url=uri, type="mongodb", sparse_collection=True, skip_pickle=True)
     o = object()
     cache.set_value("test", o)
     assert "test" in cache
     assert "test" in cache
     assert "foo" not in cache
     assert "foo" not in cache
     cache.remove_value("test")
     assert "test" not in cache

예제 #30

파일: base.py 프로젝트: ardeois/beaker

 def test_long_unicode_keys(self):
     cache = Cache('test', **self.CACHE_ARGS)
     o = object()
     long_str = u_(
         'Очень длинная строка, которая не влезает в сто двадцать восемь байт и поэтому не проходит ограничение в check_key, что очень прискорбно, не правда ли, друзья? Давайте же скорее исправим это досадное недоразумение!'
     )
     cache.set_value(long_str, o)
     assert long_str in cache
     cache.remove_value(long_str)
     assert long_str not in cache

예제 #31

 def setUp(self):
     self.cache = Cache(
         "testns",
         type="cassandra_cql",
         url="localhost:9042",
         keyspace=self.__keyspace,
         column_family=self.__table,
         serializer="json",
     )
     self.cache.clear()

예제 #32

class TestRedisJson(RedisTestOverrides, CommonMethodMixin, unittest.TestCase):
    def setUp(self):
        self.cache = Cache("testns", type="ext:redis", url="redis://localhost:6379", serializer="json")
        self.cache.clear()

    @nottest
    def test_store_obj(self):
        # We can't store objects with the json serializer so skip this test from
        # the CommonMethodMixin.
        pass

예제 #33

파일: test_redis.py 프로젝트: DataDog/beaker_extensions

class TestRedisJson(RedisTestOverrides, CommonMethodMixin, unittest.TestCase):
    def setUp(self):
        self.cache = Cache("testns", type="ext:redis", url="redis://localhost:6379", serializer="json")
        self.cache.clear()

    @nottest
    def test_store_obj(self):
        # We can't store objects with the json serializer so skip this test from
        # the CommonMethodMixin.
        pass

예제 #34

파일: test_default.py 프로젝트: SUNET/mongodb_beaker

 def test_client(self):
     cache = Cache('test', data_dir='./cache', url=uri, type="mongodb")
     o = object()
     cache.set_value("test", o)
     assert "test" in cache
     assert "test" in cache
     assert "foo" not in cache
     assert "foo" not in cache
     cache.remove_value("test")
     assert "test" not in cache

예제 #35

파일: base.py 프로젝트: ardeois/beaker

 def test_spaces_in_keys(self):
     cache = Cache('test', **self.CACHE_ARGS)
     cache.set_value("has space", 24)
     assert cache.has_key("has space")
     assert 24 == cache.get_value("has space")
     cache.set_value("hasspace", 42)
     assert cache.has_key("hasspace")
     assert 42 == cache.get_value("hasspace")

예제 #36

파일: test_nopickle.py 프로젝트: SoftwareMaven/mongodb_beaker

def test_spaces_in_keys():
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb', sparse_collection=True, skip_pickle=True)
    cache.set_value("has space", 24)
    assert cache.has_key("has space")
    assert 24 == cache.get_value("has space")
    cache.set_value("hasspace", 42)
    assert cache.has_key("hasspace")
    assert 42 == cache.get_value("hasspace")

예제 #37

파일: test_memcached.py 프로젝트: C-Pro/beaker

def test_spaces_in_keys():
    cache = Cache("test", data_dir="./cache", url=mc_url, type="ext:memcached")
    cache.set_value("has space", 24)
    assert cache.has_key("has space")
    assert 24 == cache.get_value("has space")
    cache.set_value("hasspace", 42)
    assert cache.has_key("hasspace")
    assert 42 == cache.get_value("hasspace")

예제 #38

파일: test_memcached.py 프로젝트: 01-/beaker

def test_spaces_in_keys():
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    cache.set_value("has space", 24)
    assert cache.has_key("has space")
    assert 24 == cache.get_value("has space")
    cache.set_value("hasspace", 42)
    assert cache.has_key("hasspace")
    assert 42 == cache.get_value("hasspace")

예제 #39

파일: test_default.py 프로젝트: BlueDragonX/beaker_mongodb

def test_spaces_in_keys():
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb')
    cache.set_value("has space", 24)
    assert cache.has_key("has space")
    assert 24 == cache.get_value("has space")
    cache.set_value("hasspace", 42)
    assert cache.has_key("hasspace")
    assert 42 == cache.get_value("hasspace")

예제 #40

파일: test_cassandra_cql.py 프로젝트: DataDog/beaker_extensions

    def setUpClass(cls):
        Cache.add_backend('cassandra_cql', CassandraCqlManager)
        import cassandra
        from cassandra.cluster import Cluster

        cluster = Cluster()
        cls.__session = cluster.connect()
        try:
            cls.__create_keyspace()
        except cassandra.AlreadyExists:
            cls.__delete_keyspace()
            cls.__create_keyspace()

예제 #41

    def setUpClass(cls):
        Cache.add_backend('cassandra_cql', CassandraCqlManager)
        import cassandra
        from cassandra.cluster import Cluster

        cluster = Cluster()
        cls.__session = cluster.connect()
        try:
            cls.__create_keyspace()
        except cassandra.AlreadyExists:
            cls.__delete_keyspace()
            cls.__create_keyspace()

예제 #42

파일: base.py 프로젝트: isabella232/beaker-1

 def test_clear(self):
     cache = Cache("test", **self.CACHE_ARGS)
     cache.set_value("test", 20)
     cache.set_value("fred", 10)
     assert cache.has_key("test")
     assert "test" in cache
     assert cache.has_key("fred")
     cache.clear()
     assert not cache.has_key("test")

예제 #43

파일: base.py 프로젝트: xiaohanghang/beaker

 def test_clear(self):
     cache = Cache('test', **self.CACHE_ARGS)
     cache.set_value('test', 20)
     cache.set_value('fred', 10)
     assert cache.has_key('test')
     assert 'test' in cache
     assert cache.has_key('fred')
     cache.clear()
     assert not cache.has_key("test")

예제 #44

파일: test_memcached.py 프로젝트: 01-/beaker

def test_deleting_keys():
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    cache.set_value('test', 20)

    # Nuke the keys dict, it might die, who knows
    cache.namespace.mc.delete('test:keys')

    assert cache.has_key('test')

    # make sure we can still delete keys even though our keys dict got nuked
    del cache['test']

    assert not cache.has_key('test')

예제 #45

파일: test_nopickle.py 프로젝트: xonatius/mongodb_beaker

def test_spaces_in_keys():
    cache = Cache('test',
                  data_dir='./cache',
                  url=uri,
                  type='mongodb',
                  sparse_collection=True,
                  skip_pickle=True)
    cache.set_value("has space", 24)
    assert cache.has_key("has space")
    assert 24 == cache.get_value("has space")
    cache.set_value("hasspace", 42)
    assert cache.has_key("hasspace")
    assert 42 == cache.get_value("hasspace")

예제 #46

파일: base.py 프로젝트: xiaohanghang/beaker

 def test_has_key(self):
     cache = Cache('test', **self.CACHE_ARGS)
     o = object()
     cache.set_value("test", o)
     assert cache.has_key("test")
     assert "test" in cache
     assert not cache.has_key("foo")
     assert "foo" not in cache
     cache.remove_value("test")
     assert not cache.has_key("test")

예제 #47

def test_has_key():
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    assert "test" in cache
    assert not cache.has_key("foo")
    assert "foo" not in cache
    cache.remove_value("test")
    assert not cache.has_key("test")

예제 #48

def test_clearing_cache():
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb_gridfs')
    cache.set_value('test', 20)
    cache.set_value('fred', 10)
    assert cache.has_key('test')
    assert 'test' in cache
    assert cache.has_key('fred')

    cache.clear()
    assert not cache.has_key('test')

예제 #49

def test_has_key():
    cache = Cache("test", data_dir="./cache", type="dbm")
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    assert "test" in cache
    assert not cache.has_key("foo")
    assert "foo" not in cache
    cache.remove_value("test")
    assert not cache.has_key("test")

예제 #50

파일: test_default.py 프로젝트: xonatius/mongodb_beaker

 def test_client(self):
     cache = Cache('test', data_dir='./cache', url=uri, type="mongodb")
     o = object()
     cache.set_value("test", o)
     assert cache.has_key("test")
     assert "test" in cache
     assert not cache.has_key("foo")
     assert "foo" not in cache
     cache.remove_value("test")
     assert not cache.has_key("test")

예제 #51

def test_has_key():
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb_gridfs')
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    assert "test" in cache
    assert not cache.has_key("foo")
    assert "foo" not in cache
    cache.remove_value("test")
    assert not cache.has_key("test")

예제 #52

def test_clear():
    cache = Cache('test', url=db_url, type=db_type, database=db_name)
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    cache.clear()
    assert not cache.has_key("test")

예제 #53

파일: test_database.py 프로젝트: maduhu/HDP-hue

def test_clear():
    cache = Cache('test', data_dir='./cache', url=db_url, type='ext:database')
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    cache.clear()
    assert not cache.has_key("test")

예제 #54

파일: test_database.py 프로젝트: isabella232/beaker-1

def test_clear():
    cache = Cache("test", data_dir="./cache", url=db_url, type="ext:database")
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    cache.clear()
    assert not cache.has_key("test")

예제 #55

class CassandraCqlJsonSetup(object):
    __keyspace = "test_ks"
    __table = "test_table"

    def setUp(self):
        self.cache = Cache(
            "testns",
            type="cassandra_cql",
            url="localhost:9042",
            keyspace=self.__keyspace,
            column_family=self.__table,
            serializer="json",
        )
        self.cache.clear()

예제 #56

파일: base.py 프로젝트: xiaohanghang/beaker

 def test_has_key_multicache(self):
     cache = Cache('test', **self.CACHE_ARGS)
     o = object()
     cache.set_value("test", o)
     assert cache.has_key("test")
     assert "test" in cache
     cache = Cache('test', **self.CACHE_ARGS)
     assert cache.has_key("test")

예제 #57

def test_has_key_multicache():
    cache = Cache("test", data_dir="./cache", url=mc_url, type="ext:memcached")
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    assert "test" in cache
    cache = Cache("test", data_dir="./cache", url=mc_url, type="ext:memcached")
    assert cache.has_key("test")

예제 #58

def test_has_key_multicache():
    cache = Cache("test", data_dir="./cache", type="dbm")
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    assert "test" in cache
    cache = Cache("test", data_dir="./cache", type="dbm")
    assert cache.has_key("test")

예제 #59

파일: test_default.py 프로젝트: xonatius/mongodb_beaker

def test_has_key_multicache():
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb')
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    assert "test" in cache
    cache = Cache('test', data_dir='./cache', url=uri, type='mongodb')
    assert cache.has_key("test")

예제 #60

def test_has_key_multicache():
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    o = object()
    cache.set_value("test", o)
    assert cache.has_key("test")
    assert "test" in cache
    cache = Cache('test', data_dir='./cache', url=mc_url, type='ext:memcached')
    assert cache.has_key("test")