def test_expire(self):
        import time

        quick_c = SimpleCache()
        quick_c.store("foo", "bar", expire=1)
        time.sleep(1.1)
        self.assertRaises(ExpiredKeyException, quick_c.get, "foo")
        quick_c.flush()
 def test_flush_multiple(self):
     c1 = SimpleCache(10, namespace=__name__)
     c2 = SimpleCache(10)
     c1.store("foo", "bar")
     c2.store("foo", "bar")
     c1.flush()
     self.assertEqual(len(c1), 0)
     self.assertEqual(len(c2), 1)
     c2.flush()
Example #3
0
    def test_expire(self):
        quick_c = SimpleCache()

        quick_c.store("foo", "bar", expire=1)
        time.sleep(1.1)
        self.assertRaises(ExpiredKeyException, quick_c.get, "foo")
        quick_c.flush()

        quick_c.store("foo", "bar", expire=timedelta(seconds=1))
        time.sleep(1.1)
        self.assertRaises(ExpiredKeyException, quick_c.get, "foo")
        quick_c.flush()
Example #4
0
    def test_utf8_key_support(self):
        error = "{0} raised unexpected {1}"
        c = SimpleCache(namespace=u"ÄÖÜÀÁßäöüàá")
        ustr = u"ÄÖÜÀÁßäöüàá"

        try:
            c.make_key(ustr)
        except UnicodeEncodeError as e:
            self.fail(error.format("make_key", e.__class__.__name__))

        try:
            c.get_set_name()
        except UnicodeEncodeError as e:
            self.fail(error.format("get_set_name", e.__class__.__name__))

        try:
            c.isexpired(ustr)
        except UnicodeEncodeError as e:
            self.fail(error.format("isexpired", e.__class__.__name__))
    def test_utf8_key_support(self):
        error = "{0} raised unexpected {1}"
        c = SimpleCache(namespace=u"ÄÖÜÀÁßäöüàá")
        ustr = u"ÄÖÜÀÁßäöüàá"

        try:
            c.make_key(ustr)
        except UnicodeEncodeError as e:
            self.fail(error.format("make_key", e.__class__.__name__))

        try:
            c.get_set_name()
        except UnicodeEncodeError as e:
            self.fail(error.format("get_set_name", e.__class__.__name__))

        try:
            c.isexpired(ustr)
        except UnicodeEncodeError as e:
            self.fail(error.format("isexpired", e.__class__.__name__))
Example #6
0
 def test_flush_multiple(self):
     c1 = SimpleCache(10, namespace=__name__)
     c2 = SimpleCache(10)
     c1.store("foo", "bar")
     c2.store("foo", "bar")
     c1.flush()
     self.assertEqual(len(c1), 0)
     self.assertEqual(len(c2), 1)
     c2.flush()
Example #7
0
 def setUp(self):
     self.c = SimpleCache(10)  # Cache that has a maximum limit of 10 keys
     self.assertIsNotNone(self.c.connection)
     self.redis = RedisConnect().connect()
Example #8
0
class SimpleCacheTest(TestCase):
    def setUp(self):
        self.c = SimpleCache(10)  # Cache that has a maximum limit of 10 keys
        self.assertIsNotNone(self.c.connection)
        self.redis = RedisConnect().connect()

    def test_expire(self):
        quick_c = SimpleCache()

        quick_c.store("foo", "bar", expire=1)
        time.sleep(1.1)
        self.assertRaises(ExpiredKeyException, quick_c.get, "foo")
        quick_c.flush()

        quick_c.store("foo", "bar", expire=timedelta(seconds=1))
        time.sleep(1.1)
        self.assertRaises(ExpiredKeyException, quick_c.get, "foo")
        quick_c.flush()

    def test_miss(self):
        self.assertRaises(CacheMissException, self.c.get, "blablabla")

    def test_kwargs_decorator(self):
        @cache_it_json(cache=self.c)
        def add_it(a, b=10, c=5):
            return a + b + c

        add_it(3)
        self.assertEqual(add_it(3), 18)
        add_it(5, b=7)
        self.assertEqual(add_it(5, b=7), 17)
        add_it(6, c=3)
        self.assertEqual(add_it(6, c=3), 19)

    def test_store_retrieve(self):
        self.c.store("foo", "bar")
        foo = self.c.get("foo")
        self.assertEqual(foo, b"bar")

    def test_json(self):
        payload = {"example": "data"}
        self.c.store_json("json", payload)
        self.assertEqual(self.c.get_json("json"), payload)

    def test_pickle(self):
        payload = ComplexNumber(3, 4)
        self.c.store_pickle("pickle", payload)
        self.assertEqual(self.c.get_pickle("pickle"), payload)

    def test_decorator(self):
        self.redis.flushall()
        mutable = []

        @cache_it(cache=self.c)
        def append(n):
            mutable.append(n)
            return mutable

        append(1)
        len_before = len(mutable)
        mutable_cached = append(1)
        len_after = len(mutable)
        self.assertEqual(len_before, len_after)
        self.assertNotEqual(id(mutable), id(mutable_cached))
        self.assertEqual(mutable, mutable_cached)

    def test_decorator_do_not_cache(self):
        @cache_it(cache=self.c)
        def test_no_cache(n):
            result = n * 10
            raise DoNotCache(result)

        keys_before = len(self.c.keys())
        r1 = test_no_cache(20)
        r2 = test_no_cache(10)
        r3 = test_no_cache(30)
        r4 = test_no_cache(20)

        self.assertEqual(r1, (10 * 20))
        self.assertEqual(r2, (10 * 10))
        self.assertEqual(r3, (10 * 30))
        self.assertEqual(r4, (10 * 20))

        keys_after = len(self.c.keys())

        self.assertEqual(keys_before, keys_after)

    def test_decorator_do_not_cache_reraised(self):
        @cache_it(cache=self.c)
        def test_no_cache(n):
            result = n * 10
            try:
                raise DoNotCache(result)
            except DoNotCache as e:
                raise e
            except Exception:
                pass

        keys_before = len(self.c.keys())
        r1 = test_no_cache(20)
        r2 = test_no_cache(10)
        r3 = test_no_cache(30)
        r4 = test_no_cache(20)

        self.assertEqual(r1, (10 * 20))
        self.assertEqual(r4, (10 * 20))
        self.assertEqual(r2, (10 * 10))
        self.assertEqual(r3, (10 * 30))

        keys_after = len(self.c.keys())

        self.assertEqual(keys_before, keys_after)

    def test_decorator_do_not_cache_wrapping_exception(self):
        @cache_it(cache=self.c)
        def test_no_cache(n):
            try:
                result = n / 0
            except ZeroDivisionError as e:
                raise DoNotCache(e)

        keys_before = len(self.c.keys())
        r1 = test_no_cache(20)
        self.assertTrue(isinstance(r1, ZeroDivisionError))
        keys_after = len(self.c.keys())
        self.assertEqual(keys_before, keys_after)

    def test_decorator_json(self):
        import random

        mutable = {}

        @cache_it_json(cache=self.c)
        def set_key(n):
            mutable[str(random.random())] = n
            return mutable

        set_key('a')
        len_before = len(mutable)
        mutable_cached = set_key('a')
        len_after = len(mutable)
        self.assertEqual(len_before, len_after)
        self.assertNotEqual(id(mutable), id(mutable_cached))
        self.assertEqual(mutable, mutable_cached)

    def test_decorator_complex_type(self):
        import math

        @cache_it(cache=self.c)
        def add(x, y):
            return ComplexNumber(x.real + y.real, x.imag + y.imag)

        result = add(ComplexNumber(3, 4), ComplexNumber(4, 5))
        result_cached = add(ComplexNumber(3, 4), ComplexNumber(4, 5))
        self.assertNotEqual(id(result), id(result_cached))
        self.assertEqual(result, result_cached)
        self.assertEqual(result, complex(3, 4) + complex(4, 5))

    def test_cache_limit(self):
        for i in range(100):
            self.c.store("foo%d" % i, "foobar")
            self.assertTrue(len(self.c) <= 10)
            self.assertTrue(len(self.c.keys()) <= 10)

    def test_flush(self):
        connection = self.c.connection
        connection.set("will_not_be_deleted", '42')
        self.c.store("will_be_deleted", '10')
        len_before = len(self.c)
        len_keys_before = len(connection.keys(self.c.make_key("*")))
        self.c.flush()
        len_after = len(self.c)
        len_keys_after = connection.get("will_not_be_deleted")
        self.assertTrue(len_before > 0)
        self.assertEqual(len_after, 0)
        self.assertTrue(len_keys_before > 0)
        self.assertEqual(len_keys_after, b'42')
        self.assertEqual(connection.get("will_not_be_deleted"), b'42')
        connection.delete("will_not_be_deleted")

    def test_flush_namespace(self):
        self.redis.flushall()
        self.c.store("foo:one", "bir")
        self.c.store("foo:two", "bor")
        self.c.store("fii", "bur")
        len_keys_before = len(self.c.keys())
        self.c.flush_namespace('foo')
        len_keys_after = len(self.c.keys())
        self.assertEqual((len_keys_before - len_keys_after), 2)
        self.assertEqual(self.c.get('fii'), b'bur')
        self.assertRaises(CacheMissException, self.c.get, "foo:one")
        self.assertRaises(CacheMissException, self.c.get, "foo:two")
        self.c.flush()

    def test_flush_multiple(self):
        c1 = SimpleCache(10, namespace=__name__)
        c2 = SimpleCache(10)
        c1.store("foo", "bar")
        c2.store("foo", "bar")
        c1.flush()
        self.assertEqual(len(c1), 0)
        self.assertEqual(len(c2), 1)
        c2.flush()

    def test_expire_all_in_set(self):
        self.c.store("foo", "bir")
        self.c.store("fuu", "bor")
        self.c.store("fii", "bur")
        self.assertEqual(self.c.expire_all_in_set(), (3, 3))
        self.assertRaises(ExpiredKeyException, self.c.get, "foo")
        self.assertRaises(ExpiredKeyException, self.c.get, "fuu")
        self.assertRaises(ExpiredKeyException, self.c.get, "fii")
        self.assertTrue(self.c.isexpired("foo"))
        self.assertTrue(self.c.isexpired("fuu"))
        self.assertTrue(self.c.isexpired("fii"))

    def test_expire_namespace(self):
        self.c.store("foo:one", "bir")
        self.c.store("foo:two", "bor")
        self.c.store("fii", "bur")
        self.assertEqual(self.c.expire_namespace('foo'), (3, 2))
        self.assertRaises(ExpiredKeyException, self.c.get, "foo:one")
        self.assertRaises(ExpiredKeyException, self.c.get, "foo:two")
        self.assertTrue(self.c.isexpired("foo:one"))
        self.assertTrue(self.c.isexpired("foo:two"))
        self.assertTrue(self.c.isexpired("fii") > 0)
        self.c.flush()

    def test_mget(self):
        self.c.store("a1", "a")
        self.c.store("a2", "aa")
        self.c.store("a3", "aaa")
        d = self.c.mget(["a1", "a2", "a3"])
        self.assertEqual(d["a1"], b"a")
        self.assertEqual(d["a2"], b"aa")
        self.assertEqual(d["a3"], b"aaa")

    def test_mget_nonexistant_key(self):
        self.c.store("b1", "b")
        self.c.store("b3", "bbb")
        d = self.c.mget(["b1", "b2", "b3"])
        self.assertEqual(d["b1"], b"b")
        self.assertTrue("b2" not in d)
        self.assertEqual(d["b3"], b"bbb")

    def test_mget_expiry(self):
        self.c.store("c1", "c")
        self.c.store("c2", "cc", expire=1)
        self.c.store("c3", "ccc")
        time.sleep(1.1)
        d = self.c.mget(["c1", "c2", "c3"])
        self.assertEqual(d["c1"], b"c")
        self.assertTrue("c2" not in d)
        self.assertEqual(d["c3"], b"ccc")

    def test_mget_json(self):
        payload_a1 = {"example_a1": "data_a1"}
        payload_a2 = {"example_a2": "data_a2"}
        self.c.store_json("json_a1", payload_a1)
        self.c.store_json("json_a2", payload_a2)
        d = self.c.mget_json(["json_a1", "json_a2"])
        self.assertEqual(d["json_a1"], payload_a1)
        self.assertEqual(d["json_a2"], payload_a2)

    def test_mget_json_nonexistant_key(self):
        payload_b1 = {"example_b1": "data_b1"}
        payload_b3 = {"example_b3": "data_b3"}
        self.c.store_json("json_b1", payload_b1)
        self.c.store_json("json_b3", payload_b3)
        d = self.c.mget_json(["json_b1", "json_b2", "json_b3"])
        self.assertEqual(d["json_b1"], payload_b1)
        self.assertTrue("json_b2" not in d)
        self.assertEqual(d["json_b3"], payload_b3)

    def test_invalidate_key(self):
        self.c.store("d1", "d")
        self.c.store("d2", "dd")
        self.c.store("d3", "ddd")
        self.c.invalidate("d2")
        d = self.c.mget(["d1", "d2", "d3"])
        self.assertEqual(d["d1"], b"d")
        self.assertTrue(b"d2" not in d)
        self.assertEqual(d["d3"], b"ddd")

    def tearDown(self):
        self.c.flush()
 def setUp(self):
     self.c = SimpleCache(10)  # Cache that has a maximum limit of 10 keys
     self.assertIsNotNone(self.c.connection)
class SimpleCacheTest(TestCase):

    def setUp(self):
        self.c = SimpleCache(10)  # Cache that has a maximum limit of 10 keys
        self.assertIsNotNone(self.c.connection)

    def test_expire(self):
        quick_c = SimpleCache()
        quick_c.store("foo", "bar", expire=1)
        time.sleep(1.1)
        self.assertRaises(ExpiredKeyException, quick_c.get, "foo")
        quick_c.flush()

    def test_miss(self):
        self.assertRaises(CacheMissException, self.c.get, "blablabla")

    def test_kwargs_decorator(self):
        @cache_it_json(cache=self.c)
        def add_it(a, b=10, c=5):
            return a + b + c
        add_it(3)
        self.assertEqual(add_it(3), 18)
        add_it(5, b=7)
        self.assertEqual(add_it(5, b=7), 17)
        add_it(6, c=3)
        self.assertEqual(add_it(6, c=3), 19)

    def test_store_retrieve(self):
        self.c.store("foo", "bar")
        foo = self.c.get("foo")
        self.assertEqual(foo, "bar")

    def test_json(self):
        payload = {"example": "data"}
        self.c.store_json("json", payload)
        self.assertEqual(self.c.get_json("json"), payload)

    def test_pickle(self):
        payload = ComplexNumber(3,4)
        self.c.store_pickle("pickle", payload)
        self.assertEqual(self.c.get_pickle("pickle"), payload)

    def test_decorator(self):
        mutable = []
        @cache_it(cache=self.c)
        def append(n):
            mutable.append(n)
            return mutable
        append(1)
        len_before = len(mutable)
        mutable_cached = append(1)
        len_after = len(mutable)
        self.assertEqual(len_before, len_after)
        self.assertNotEqual(id(mutable), id(mutable_cached))
        self.assertEqual(mutable, mutable_cached)

    def test_decorator_do_not_cache(self):
        @cache_it(cache=self.c)
        def test_no_cache(n):
            result = n * 10
            raise DoNotCache(result)

        keys_before = len(self.c.keys())
        r1 = test_no_cache(20)
        r2 = test_no_cache(10)
        r3 = test_no_cache(30)
        r4 = test_no_cache(20)

        self.assertEqual(r1, (10 * 20))
        self.assertEqual(r2, (10 * 10))
        self.assertEqual(r3, (10 * 30))
        self.assertEqual(r4, (10 * 20))

        keys_after = len(self.c.keys())

        self.assertEqual(keys_before, keys_after)

    def test_decorator_do_not_cache_reraised(self):
        @cache_it(cache=self.c)
        def test_no_cache(n):
            result = n * 10
            try:
                raise DoNotCache(result)
            except DoNotCache as e:
                raise e
            except Exception:
                pass

        keys_before = len(self.c.keys())
        r1 = test_no_cache(20)
        r2 = test_no_cache(10)
        r3 = test_no_cache(30)
        r4 = test_no_cache(20)

        self.assertEqual(r1, (10 * 20))
        self.assertEqual(r4, (10 * 20))
        self.assertEqual(r2, (10 * 10))
        self.assertEqual(r3, (10 * 30))

        keys_after = len(self.c.keys())

        self.assertEqual(keys_before, keys_after)

    def test_decorator_do_not_cache_wrapping_exception(self):
        @cache_it(cache=self.c)
        def test_no_cache(n):
            try:
                result = n / 0
            except ZeroDivisionError as e:
                raise DoNotCache(e)

        keys_before = len(self.c.keys())
        r1 = test_no_cache(20)
        self.assertTrue(isinstance(r1, ZeroDivisionError))
        keys_after = len(self.c.keys())
        self.assertEqual(keys_before, keys_after)

    def test_decorator_json(self):
        import random

        mutable = {}
        @cache_it_json(cache=self.c)
        def set_key(n):
            mutable[str(random.random())] = n
            return mutable
        set_key('a')
        len_before = len(mutable)
        mutable_cached = set_key('a')
        len_after = len(mutable)
        self.assertEqual(len_before, len_after)
        self.assertNotEqual(id(mutable), id(mutable_cached))
        self.assertEqual(mutable, mutable_cached)

    def test_decorator_complex_type(self):
        import math

        @cache_it(cache=self.c)
        def add(x, y):
            return ComplexNumber(x.real + y.real, x.imag + y.imag)
        result = add(ComplexNumber(3,4), ComplexNumber(4,5))
        result_cached = add(ComplexNumber(3,4), ComplexNumber(4,5))
        self.assertNotEqual(id(result), id(result_cached))
        self.assertEqual(result, result_cached)
        self.assertEqual(result, complex(3,4) + complex(4,5))

    def test_cache_limit(self):
        for i in range(100):
            self.c.store("foo%d" % i, "foobar")
            self.failUnless(len(self.c) <= 10)
            self.failUnless(len(self.c.keys()) <= 10)

    def test_flush(self):
        connection = self.c.connection
        connection.set("will_not_be_deleted", '42')
        self.c.store("will_be_deleted", '10')
        len_before = len(self.c)
        len_keys_before = len(connection.keys(self.c.make_key("*")))
        self.c.flush()
        len_after = len(self.c)
        len_keys_after = len(connection.keys(self.c.make_key("*")))
        self.assertEqual(len_before, 1)
        self.assertEqual(len_after, 0)
        self.assertEqual(len_keys_before, 1)
        self.assertEqual(len_keys_after, 0)
        self.assertEqual(connection.get("will_not_be_deleted"), '42')
        connection.delete("will_not_be_deleted")

    def test_flush_namespace(self):
        self.c.store("foo:one", "bir")
        self.c.store("foo:two", "bor")
        self.c.store("fii", "bur")
        len_keys_before = len(self.c.keys())
        self.c.flush_namespace('foo')
        len_keys_after = len(self.c.keys())
        self.assertEqual((len_keys_before - len_keys_after), 2)
        self.assertEqual(self.c.get('fii'), 'bur')
        self.assertRaises(CacheMissException, self.c.get, "foo:one")
        self.assertRaises(CacheMissException, self.c.get, "foo:two")
        self.c.flush()

    def test_flush_multiple(self):
        c1 = SimpleCache(10, namespace=__name__)
        c2 = SimpleCache(10)
        c1.store("foo", "bar")
        c2.store("foo", "bar")
        c1.flush()
        self.assertEqual(len(c1), 0)
        self.assertEqual(len(c2), 1)
        c2.flush()

    def test_expire_all_in_set(self):
        self.c.store("foo", "bir")
        self.c.store("fuu", "bor")
        self.c.store("fii", "bur")
        self.assertEqual(self.c.expire_all_in_set(), (3, 3))
        self.assertRaises(ExpiredKeyException, self.c.get, "foo")
        self.assertRaises(ExpiredKeyException, self.c.get, "fuu")
        self.assertRaises(ExpiredKeyException, self.c.get, "fii")
        self.assertTrue(self.c.isexpired("foo"))
        self.assertTrue(self.c.isexpired("fuu"))
        self.assertTrue(self.c.isexpired("fii"))

    def test_expire_namespace(self):
        self.c.store("foo:one", "bir")
        self.c.store("foo:two", "bor")
        self.c.store("fii", "bur")
        self.assertEqual(self.c.expire_namespace('foo'), (3, 2))
        self.assertRaises(ExpiredKeyException, self.c.get, "foo:one")
        self.assertRaises(ExpiredKeyException, self.c.get, "foo:two")
        self.assertTrue(self.c.isexpired("foo:one"))
        self.assertTrue(self.c.isexpired("foo:two"))
        self.assertTrue(self.c.isexpired("fii") > 0)
        self.c.flush()

    def test_mget(self):
        self.c.store("a1", "a")
        self.c.store("a2", "aa")
        self.c.store("a3", "aaa")
        d = self.c.mget(["a1", "a2", "a3"])
        self.assertEqual(d["a1"], "a")
        self.assertEqual(d["a2"], "aa")
        self.assertEqual(d["a3"], "aaa")

    def test_mget_nonexistant_key(self):
        self.c.store("b1", "b")
        self.c.store("b3", "bbb")
        d = self.c.mget(["b1", "b2", "b3"])
        self.assertEqual(d["b1"], "b")
        self.assertTrue("b2" not in d)
        self.assertEqual(d["b3"], "bbb")

    def test_mget_expiry(self):
        self.c.store("c1", "c")
        self.c.store("c2", "cc", expire=1)
        self.c.store("c3", "ccc")
        time.sleep(1.1)
        d = self.c.mget(["c1", "c2", "c3"])
        self.assertEqual(d["c1"], "c")
        self.assertTrue("c2" not in d)
        self.assertEqual(d["c3"], "ccc")

    def test_mget_json(self):
        payload_a1 = {"example_a1": "data_a1"}
        payload_a2 = {"example_a2": "data_a2"}
        self.c.store_json("json_a1", payload_a1)
        self.c.store_json("json_a2", payload_a2)
        d = self.c.mget_json(["json_a1", "json_a2"])
        self.assertEqual(d["json_a1"], payload_a1)
        self.assertEqual(d["json_a2"], payload_a2)

    def test_mget_json_nonexistant_key(self):
        payload_b1 = {"example_b1": "data_b1"}
        payload_b3 = {"example_b3": "data_b3"}
        self.c.store_json("json_b1", payload_b1)
        self.c.store_json("json_b3", payload_b3)
        d = self.c.mget_json(["json_b1", "json_b2", "json_b3"])
        self.assertEqual(d["json_b1"], payload_b1)
        self.assertTrue("json_b2" not in d)
        self.assertEqual(d["json_b3"], payload_b3)

    def test_invalidate_key(self):
        self.c.store("d1", "d")
        self.c.store("d2", "dd")
        self.c.store("d3", "ddd")
        self.c.invalidate("d2")
        d = self.c.mget(["d1", "d2", "d3"])
        self.assertEqual(d["d1"], "d")
        self.assertTrue("d2" not in d)
        self.assertEqual(d["d3"], "ddd")

    def tearDown(self):
        self.c.flush()
class SimpleCacheTest(TestCase):

    def setUp(self):
        self.c = SimpleCache(10)  # Cache that has a maximum limit of 10 keys
        self.assertIsNotNone(self.c.connection)

    def test_expire(self):
        import time

        quick_c = SimpleCache()
        quick_c.store("foo", "bar", expire=1)
        time.sleep(1.1)
        self.assertRaises(ExpiredKeyException, quick_c.get, "foo")
        quick_c.flush()

    def test_miss(self):
        self.assertRaises(CacheMissException, self.c.get, "blablabla")

    def test_kwargs_decorator(self):
        @cache_it_json(cache=self.c)
        def add_it(a, b=10, c=5):
            return a + b + c
        add_it(3)
        self.assertEqual(add_it(3), 18)
        add_it(5, b=7)
        self.assertEqual(add_it(5, b=7), 17)
        add_it(6, c=3)
        self.assertEqual(add_it(6, c=3), 19)

    def test_store_retrieve(self):
        self.c.store("foo", "bar")
        foo = self.c.get("foo")
        self.assertEqual(foo, "bar")

    def test_json(self):
        payload = {"example": "data"}
        self.c.store_json("json", payload)
        self.assertEqual(self.c.get_json("json"), payload)

    def test_pickle(self):
        payload = ComplexNumber(3,4)
        self.c.store_pickle("pickle", payload)
        self.assertEqual(self.c.get_pickle("pickle"), payload)

    def test_decorator(self):
        mutable = []
        @cache_it(cache=self.c)
        def append(n):
            mutable.append(n)
            return mutable
        append(1)
        len_before = len(mutable)
        mutable_cached = append(1)
        len_after = len(mutable)
        self.assertEqual(len_before, len_after)
        self.assertNotEqual(id(mutable), id(mutable_cached))
        self.assertEqual(mutable, mutable_cached)

    def test_decorator_json(self):
        import random

        mutable = {}
        @cache_it_json(cache=self.c)
        def set_key(n):
            mutable[str(random.random())] = n
            return mutable
        set_key('a')
        len_before = len(mutable)
        mutable_cached = set_key('a')
        len_after = len(mutable)
        self.assertEqual(len_before, len_after)
        self.assertNotEqual(id(mutable), id(mutable_cached))
        self.assertEqual(mutable, mutable_cached)

    def test_decorator_complex_type(self):
        import math

        @cache_it(cache=self.c)
        def add(x, y):
            return ComplexNumber(x.real + y.real, x.imag + y.imag)
        result = add(ComplexNumber(3,4), ComplexNumber(4,5))
        result_cached = add(ComplexNumber(3,4), ComplexNumber(4,5))
        self.assertNotEqual(id(result), id(result_cached))
        self.assertEqual(result, result_cached)
        self.assertEqual(result, complex(3,4) + complex(4,5))

    def test_cache_limit(self):
        for i in range(100):
            self.c.store("foo%d" % i, "foobar")
            self.failUnless(len(self.c) <= 10)
            self.failUnless(len(self.c.keys()) <= 10)

    def test_flush(self):
        connection = self.c.connection
        connection.set("will_not_be_deleted", '42')
        self.c.store("will_be_deleted", '10')
        len_before = len(self.c)
        len_keys_before = len(connection.keys(self.c.make_key("*")))
        self.c.flush()
        len_after = len(self.c)
        len_keys_after = len(connection.keys(self.c.make_key("*")))
        self.assertEqual(len_before, 1)
        self.assertEqual(len_after, 0)
        self.assertEqual(len_keys_before, 1)
        self.assertEqual(len_keys_after, 0)
        self.assertEqual(connection.get("will_not_be_deleted"), '42')
        connection.delete("will_not_be_deleted")

    def test_flush_multiple(self):
        c1 = SimpleCache(10, namespace=__name__)
        c2 = SimpleCache(10)
        c1.store("foo", "bar")
        c2.store("foo", "bar")
        c1.flush()
        self.assertEqual(len(c1), 0)
        self.assertEqual(len(c2), 1)
        c2.flush()

    def test_expire_all_in_set(self):
        self.c.store("foo", "bir")
        self.c.store("fuu", "bor")
        self.c.store("fii", "bur")
        self.assertEqual(self.c.expire_all_in_set(), (3,3))
        self.assertTrue(self.c.isexpired("foo"))
        self.assertTrue(self.c.isexpired("fuu"))
        self.assertTrue(self.c.isexpired("fii"))

    def tearDown(self):
        self.c.flush()
Example #12
0
class SimpleCacheTest(TestCase):
    def setUp(self):
        self.c = SimpleCache(10)  # Cache that has a maximum limit of 10 keys
        self.assertIsNotNone(self.c.connection)

    def test_expire(self):
        quick_c = SimpleCache()
        quick_c.store("foo", "bar", expire=1)
        time.sleep(1.1)
        self.assertRaises(ExpiredKeyException, quick_c.get, "foo")
        quick_c.flush()

    def test_miss(self):
        self.assertRaises(CacheMissException, self.c.get, "blablabla")

    def test_kwargs_decorator(self):
        @cache_it_json(cache=self.c)
        def add_it(a, b=10, c=5):
            return a + b + c

        add_it(3)
        self.assertEqual(add_it(3), 18)
        add_it(5, b=7)
        self.assertEqual(add_it(5, b=7), 17)
        add_it(6, c=3)
        self.assertEqual(add_it(6, c=3), 19)

    def test_store_retrieve(self):
        self.c.store("foo", "bar")
        foo = self.c.get("foo")
        self.assertEqual(foo, "bar")

    def test_json(self):
        payload = {"example": "data"}
        self.c.store_json("json", payload)
        self.assertEqual(self.c.get_json("json"), payload)

    def test_pickle(self):
        payload = ComplexNumber(3, 4)
        self.c.store_pickle("pickle", payload)
        self.assertEqual(self.c.get_pickle("pickle"), payload)

    def test_decorator(self):
        mutable = []

        @cache_it(cache=self.c)
        def append(n):
            mutable.append(n)
            return mutable

        append(1)
        len_before = len(mutable)
        mutable_cached = append(1)
        len_after = len(mutable)
        self.assertEqual(len_before, len_after)
        self.assertNotEqual(id(mutable), id(mutable_cached))
        self.assertEqual(mutable, mutable_cached)

    def test_decorator_json(self):
        import random

        mutable = {}

        @cache_it_json(cache=self.c)
        def set_key(n):
            mutable[str(random.random())] = n
            return mutable

        set_key('a')
        len_before = len(mutable)
        mutable_cached = set_key('a')
        len_after = len(mutable)
        self.assertEqual(len_before, len_after)
        self.assertNotEqual(id(mutable), id(mutable_cached))
        self.assertEqual(mutable, mutable_cached)

    def test_decorator_complex_type(self):
        import math

        @cache_it(cache=self.c)
        def add(x, y):
            return ComplexNumber(x.real + y.real, x.imag + y.imag)

        result = add(ComplexNumber(3, 4), ComplexNumber(4, 5))
        result_cached = add(ComplexNumber(3, 4), ComplexNumber(4, 5))
        self.assertNotEqual(id(result), id(result_cached))
        self.assertEqual(result, result_cached)
        self.assertEqual(result, complex(3, 4) + complex(4, 5))

    def test_cache_limit(self):
        for i in range(100):
            self.c.store("foo%d" % i, "foobar")
            self.failUnless(len(self.c) <= 10)
            self.failUnless(len(self.c.keys()) <= 10)

    def test_flush(self):
        connection = self.c.connection
        connection.set("will_not_be_deleted", '42')
        self.c.store("will_be_deleted", '10')
        len_before = len(self.c)
        len_keys_before = len(connection.keys(self.c.make_key("*")))
        self.c.flush()
        len_after = len(self.c)
        len_keys_after = len(connection.keys(self.c.make_key("*")))
        self.assertEqual(len_before, 1)
        self.assertEqual(len_after, 0)
        self.assertEqual(len_keys_before, 1)
        self.assertEqual(len_keys_after, 0)
        self.assertEqual(connection.get("will_not_be_deleted"), '42')
        connection.delete("will_not_be_deleted")

    def test_flush_multiple(self):
        c1 = SimpleCache(10, namespace=__name__)
        c2 = SimpleCache(10)
        c1.store("foo", "bar")
        c2.store("foo", "bar")
        c1.flush()
        self.assertEqual(len(c1), 0)
        self.assertEqual(len(c2), 1)
        c2.flush()

    def test_expire_all_in_set(self):
        self.c.store("foo", "bir")
        self.c.store("fuu", "bor")
        self.c.store("fii", "bur")
        self.assertEqual(self.c.expire_all_in_set(), (3, 3))
        self.assertTrue(self.c.isexpired("foo"))
        self.assertTrue(self.c.isexpired("fuu"))
        self.assertTrue(self.c.isexpired("fii"))

    def test_mget(self):
        self.c.store("a1", "a")
        self.c.store("a2", "aa")
        self.c.store("a3", "aaa")
        d = self.c.mget(["a1", "a2", "a3"])
        self.assertEqual(d["a1"], "a")
        self.assertEqual(d["a2"], "aa")
        self.assertEqual(d["a3"], "aaa")

    def test_mget_nonexistant_key(self):
        self.c.store("b1", "b")
        self.c.store("b3", "bbb")
        d = self.c.mget(["b1", "b2", "b3"])
        self.assertEqual(d["b1"], "b")
        self.assertTrue("b2" not in d)
        self.assertEqual(d["b3"], "bbb")

    def test_mget_expiry(self):
        self.c.store("c1", "c")
        self.c.store("c2", "cc", expire=1)
        self.c.store("c3", "ccc")
        time.sleep(1.1)
        d = self.c.mget(["c1", "c2", "c3"])
        self.assertEqual(d["c1"], "c")
        self.assertTrue("c2" not in d)
        self.assertEqual(d["c3"], "ccc")

    def test_mget_json(self):
        payload_a1 = {"example_a1": "data_a1"}
        payload_a2 = {"example_a2": "data_a2"}
        self.c.store_json("json_a1", payload_a1)
        self.c.store_json("json_a2", payload_a2)
        d = self.c.mget_json(["json_a1", "json_a2"])
        self.assertEqual(d["json_a1"], payload_a1)
        self.assertEqual(d["json_a2"], payload_a2)

    def test_mget_json_nonexistant_key(self):
        payload_b1 = {"example_b1": "data_b1"}
        payload_b3 = {"example_b3": "data_b3"}
        self.c.store_json("json_b1", payload_b1)
        self.c.store_json("json_b3", payload_b3)
        d = self.c.mget_json(["json_b1", "json_b2", "json_b3"])
        self.assertEqual(d["json_b1"], payload_b1)
        self.assertTrue("json_b2" not in d)
        self.assertEqual(d["json_b3"], payload_b3)

    def test_utf8_key_support(self):
        error = "{0} raised unexpected {1}"
        c = SimpleCache(namespace=u"ÄÖÜÀÁßäöüàá")
        ustr = u"ÄÖÜÀÁßäöüàá"

        try:
            c.make_key(ustr)
        except UnicodeEncodeError as e:
            self.fail(error.format("make_key", e.__class__.__name__))

        try:
            c.get_set_name()
        except UnicodeEncodeError as e:
            self.fail(error.format("get_set_name", e.__class__.__name__))

        try:
            c.isexpired(ustr)
        except UnicodeEncodeError as e:
            self.fail(error.format("isexpired", e.__class__.__name__))

    def tearDown(self):
        self.c.flush()
Example #13
0
 def setUp(self):
     self.c = SimpleCache(10)  # Cache that has a maximum limit of 10 keys
     self.assertIsNotNone(self.c.connection)
     from gllue.app import redis_client
     self.redis = redis_client
class SimpleCacheTest(TestCase):
    def setUp(self):
        self.c = SimpleCache(10)  # Cache that has a maximum limit of 10 keys
        self.assertIsNotNone(self.c.connection)

    def test_expire(self):
        quick_c = SimpleCache()
        quick_c.store("foo", "bar", expire=1)
        time.sleep(1.1)
        self.assertRaises(ExpiredKeyException, quick_c.get, "foo")
        quick_c.flush()

    def test_miss(self):
        self.assertRaises(CacheMissException, self.c.get, "blablabla")

    def test_kwargs_decorator(self):
        @cache_it_json(cache=self.c)
        def add_it(a, b=10, c=5):
            return a + b + c

        add_it(3)
        self.assertEqual(add_it(3), 18)
        add_it(5, b=7)
        self.assertEqual(add_it(5, b=7), 17)
        add_it(6, c=3)
        self.assertEqual(add_it(6, c=3), 19)

    def test_store_retrieve(self):
        self.c.store("foo", "bar")
        foo = self.c.get("foo")
        self.assertEqual(foo, "bar")

    def test_json(self):
        payload = {"example": "data"}
        self.c.store_json("json", payload)
        self.assertEqual(self.c.get_json("json"), payload)

    def test_pickle(self):
        payload = ComplexNumber(3, 4)
        self.c.store_pickle("pickle", payload)
        self.assertEqual(self.c.get_pickle("pickle"), payload)

    def test_decorator(self):
        mutable = []

        @cache_it(cache=self.c)
        def append(n):
            mutable.append(n)
            return mutable

        append(1)
        len_before = len(mutable)
        mutable_cached = append(1)
        len_after = len(mutable)
        self.assertEqual(len_before, len_after)
        self.assertNotEqual(id(mutable), id(mutable_cached))
        self.assertEqual(mutable, mutable_cached)

    def test_decorator_json(self):
        import random

        mutable = {}

        @cache_it_json(cache=self.c)
        def set_key(n):
            mutable[str(random.random())] = n
            return mutable

        set_key("a")
        len_before = len(mutable)
        mutable_cached = set_key("a")
        len_after = len(mutable)
        self.assertEqual(len_before, len_after)
        self.assertNotEqual(id(mutable), id(mutable_cached))
        self.assertEqual(mutable, mutable_cached)

    def test_decorator_complex_type(self):
        import math

        @cache_it(cache=self.c)
        def add(x, y):
            return ComplexNumber(x.real + y.real, x.imag + y.imag)

        result = add(ComplexNumber(3, 4), ComplexNumber(4, 5))
        result_cached = add(ComplexNumber(3, 4), ComplexNumber(4, 5))
        self.assertNotEqual(id(result), id(result_cached))
        self.assertEqual(result, result_cached)
        self.assertEqual(result, complex(3, 4) + complex(4, 5))

    def test_cache_limit(self):
        for i in range(100):
            self.c.store("foo%d" % i, "foobar")
            self.failUnless(len(self.c) <= 10)
            self.failUnless(len(self.c.keys()) <= 10)

    def test_flush(self):
        connection = self.c.connection
        connection.set("will_not_be_deleted", "42")
        self.c.store("will_be_deleted", "10")
        len_before = len(self.c)
        len_keys_before = len(connection.keys(self.c.make_key("*")))
        self.c.flush()
        len_after = len(self.c)
        len_keys_after = len(connection.keys(self.c.make_key("*")))
        self.assertEqual(len_before, 1)
        self.assertEqual(len_after, 0)
        self.assertEqual(len_keys_before, 1)
        self.assertEqual(len_keys_after, 0)
        self.assertEqual(connection.get("will_not_be_deleted"), "42")
        connection.delete("will_not_be_deleted")

    def test_flush_multiple(self):
        c1 = SimpleCache(10, namespace=__name__)
        c2 = SimpleCache(10)
        c1.store("foo", "bar")
        c2.store("foo", "bar")
        c1.flush()
        self.assertEqual(len(c1), 0)
        self.assertEqual(len(c2), 1)
        c2.flush()

    def test_expire_all_in_set(self):
        self.c.store("foo", "bir")
        self.c.store("fuu", "bor")
        self.c.store("fii", "bur")
        self.assertEqual(self.c.expire_all_in_set(), (3, 3))
        self.assertTrue(self.c.isexpired("foo"))
        self.assertTrue(self.c.isexpired("fuu"))
        self.assertTrue(self.c.isexpired("fii"))

    def test_mget(self):
        self.c.store("a1", "a")
        self.c.store("a2", "aa")
        self.c.store("a3", "aaa")
        d = self.c.mget(["a1", "a2", "a3"])
        self.assertEqual(d["a1"], "a")
        self.assertEqual(d["a2"], "aa")
        self.assertEqual(d["a3"], "aaa")

    def test_mget_nonexistant_key(self):
        self.c.store("b1", "b")
        self.c.store("b3", "bbb")
        d = self.c.mget(["b1", "b2", "b3"])
        self.assertEqual(d["b1"], "b")
        self.assertTrue("b2" not in d)
        self.assertEqual(d["b3"], "bbb")

    def test_mget_expiry(self):
        self.c.store("c1", "c")
        self.c.store("c2", "cc", expire=1)
        self.c.store("c3", "ccc")
        time.sleep(1.1)
        d = self.c.mget(["c1", "c2", "c3"])
        self.assertEqual(d["c1"], "c")
        self.assertTrue("c2" not in d)
        self.assertEqual(d["c3"], "ccc")

    def test_mget_json(self):
        payload_a1 = {"example_a1": "data_a1"}
        payload_a2 = {"example_a2": "data_a2"}
        self.c.store_json("json_a1", payload_a1)
        self.c.store_json("json_a2", payload_a2)
        d = self.c.mget_json(["json_a1", "json_a2"])
        self.assertEqual(d["json_a1"], payload_a1)
        self.assertEqual(d["json_a2"], payload_a2)

    def test_mget_json_nonexistant_key(self):
        payload_b1 = {"example_b1": "data_b1"}
        payload_b3 = {"example_b3": "data_b3"}
        self.c.store_json("json_b1", payload_b1)
        self.c.store_json("json_b3", payload_b3)
        d = self.c.mget_json(["json_b1", "json_b2", "json_b3"])
        self.assertEqual(d["json_b1"], payload_b1)
        self.assertTrue("json_b2" not in d)
        self.assertEqual(d["json_b3"], payload_b3)

    def test_utf8_key_support(self):
        error = "{0} raised unexpected {1}"
        c = SimpleCache(namespace=u"ÄÖÜÀÁßäöüàá")
        ustr = u"ÄÖÜÀÁßäöüàá"

        try:
            c.make_key(ustr)
        except UnicodeEncodeError as e:
            self.fail(error.format("make_key", e.__class__.__name__))

        try:
            c.get_set_name()
        except UnicodeEncodeError as e:
            self.fail(error.format("get_set_name", e.__class__.__name__))

        try:
            c.isexpired(ustr)
        except UnicodeEncodeError as e:
            self.fail(error.format("isexpired", e.__class__.__name__))

    def tearDown(self):
        self.c.flush()