class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open(port=11978)
        self.LARGE_KEY_LEN = 8000

    def test_increment(self):
        self.assertTrue(self.kt_handle.clear())

        key = 'incrkey'
        self.assertEqual(self.kt_handle.increment(key, 10), 10)
        self.assertEqual(self.kt_handle.increment(key, 10), 20)
        self.assertEqual(self.kt_handle.increment(key, 10), 30)
        self.assertEqual(self.kt_handle.increment(key, 10), 40)
        self.assertEqual(self.kt_handle.increment(key, 10), 50)

        # Incrementing against a non numeric value. Must fail.
        self.assertTrue(self.kt_handle.set(key, 'foo'))
        self.assertRaises(KyotoTycoonException, self.kt_handle.increment, key, 10)

    def test_increment_double(self):
        self.assertTrue(self.kt_handle.clear())

        key = 'incrkey'
        self.assertEqual(self.kt_handle.increment_double(key, 1.23), 1.23)
        self.assertEqual(self.kt_handle.increment_double(key, 1.11), 2.34)
        self.assertEqual(self.kt_handle.increment_double(key, 0.16), 2.50)
    def setUp(self):
        self.kt_handle_http = KyotoTycoon(binary=False)
        self.kt_handle_http.open(port=11978)

        self.kt_handle_bin = KyotoTycoon(binary=True)
        self.kt_handle_bin.open(port=11978)

        self.LARGE_KEY_LEN = 8000
    def setUp(self):
        self.kt_bin_handle = KyotoTycoon(binary=True,
                                         pack_type=kt_binary.KT_PACKER_BYTES)
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False,
                                          pack_type=kt_http.KT_PACKER_BYTES)
        self.kt_http_handle.open(port=11978)
    def setUp(self):
        self.kt_bin_handle = KyotoTycoon(binary=True, pack_type=kt_binary.KT_PACKER_CUSTOM,
                                                      custom_packer=CustomPacker())
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False, pack_type=kt_http.KT_PACKER_CUSTOM,
                                                        custom_packer=CustomPacker())
        self.kt_http_handle.open(port=11978)
Example #5
0
    def setUp(self):
        # For operations not supported by the binary protocol, but useful for testing it...
        self.kt_handle_http = KyotoTycoon(binary=False)
        self.kt_handle_http.open(port=11978)

        self.kt_handle = KyotoTycoon(binary=True, pack_type=KT_PACKER_PICKLE)
        self.kt_handle.open(port=11978)
        self.LARGE_KEY_LEN = 8000
    def setUp(self):
        self.kt_handle_http = KyotoTycoon(binary=False)
        self.kt_handle_http.open(port=11978)

        self.kt_handle_bin = KyotoTycoon(binary=True)
        self.kt_handle_bin.open(port=11978)

        self.LARGE_KEY_LEN = 8000
def benchmark_kyototycoon_set_bulk():
    client = KyotoTycoon()
    client.open()

    requests = _create_request()

    start = time.time()
    [client.set_bulk(req) for req in requests]
    print 'python-kyototycoon set_bulk qps:', int(NUM_REQUESTS * NUM_BULK / (time.time() - start))
Example #8
0
    def setUp(self):
        self.kt_bin_handle = KyotoTycoon(binary=True,
                                         pack_type=kt_binary.KT_PACKER_CUSTOM,
                                         custom_packer=CustomPacker())
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False,
                                          pack_type=kt_http.KT_PACKER_CUSTOM,
                                          custom_packer=CustomPacker())
        self.kt_http_handle.open(port=11978)
    def setUp(self):
        memc_packer = MemcachePacker(gzip_enabled=True, gzip_threshold=10, gzip_flag=1)

        self.kt_bin_handle = KyotoTycoon(binary=True, pack_type=kt_binary.KT_PACKER_CUSTOM,
                                                      custom_packer=memc_packer)
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False, pack_type=kt_http.KT_PACKER_CUSTOM,
                                                        custom_packer=memc_packer)
        self.kt_http_handle.open(port=11978)
Example #10
0
def benchmark_kyototycoon_set_bulk():
    client = KyotoTycoon()
    client.open()

    requests = _create_request()

    start = time.time()
    [client.set_bulk(req) for req in requests]
    print 'python-kyototycoon set_bulk qps:', int(NUM_REQUESTS * NUM_BULK /
                                                  (time.time() - start))
Example #11
0
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open()

    def test_tsv_rpc(self):
        key = 'tabbed\tkey'
        value = 'tabs\tin\tvalue'

        self.assertTrue(self.kt_handle.clear())
        self.assertEqual(self.kt_handle.increment(key, 1024), 1024)
Example #12
0
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open()

    def test_tsv_rpc(self):
        key = 'tabbed\tkey'
        value = 'tabs\tin\tvalue'

        self.assertTrue(self.kt_handle.clear())
        self.assertEqual(self.kt_handle.increment(key, 1024), 1024)
Example #13
0
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open('tiger')

    def test_set(self):
        self.assertTrue(self.kt_handle.clear())
        error = self.kt_handle.error()

        value = {"hello": "world"}
        ret = self.kt_handle.play_script('echo', value)
        self.assertEqual(ret, value)
    def setUp(self):
        memc_packer = SimpleMemcachePacker()

        self.kt_bin_handle = KyotoTycoon(binary=True,
                                         pack_type=kt_binary.KT_PACKER_CUSTOM,
                                         custom_packer=memc_packer)
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False,
                                          pack_type=kt_http.KT_PACKER_CUSTOM,
                                          custom_packer=memc_packer)
        self.kt_http_handle.open(port=11978)
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open('tiger')

    def test_set(self):
        self.assertTrue(self.kt_handle.clear())
        error = self.kt_handle.error()

        value = {
            "hello": "world"
        }
        ret = self.kt_handle.play_script('echo',value)
        self.assertEqual(ret, value)
    def setUp(self):
        memc_packer = MemcachePacker(gzip_enabled=True,
                                     gzip_threshold=10,
                                     gzip_flag=1)

        self.kt_bin_handle = KyotoTycoon(binary=True,
                                         pack_type=kt_binary.KT_PACKER_CUSTOM,
                                         custom_packer=memc_packer)
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False,
                                          pack_type=kt_http.KT_PACKER_CUSTOM,
                                          custom_packer=memc_packer)
        self.kt_http_handle.open(port=11978)
    def open_session(self, app, request):
        sid = request.cookies.get(app.session_cookie_name)
        if sid:
            stored_session = None
            try:
                stored_session = self.connection.get(sid, db=app.name)
            except BadStatusLine:
                connection = KyotoTycoon()
                connection.open(self.host, self.port)
                self.connection = connection
                stored_session = self.connection.get(sid, db=app.name)

            if stored_session:
                return KyotoTycoonSession(initial=stored_session['data'],
                                          sid=stored_session['sid'])
        sid = str(uuid4())
        return KyotoTycoonSession(sid=sid)
    def open_session(self, app, request):
        sid = request.cookies.get(app.session_cookie_name)
        if sid:
            stored_session = None
            try:
                stored_session = self.connection.get(sid, db=app.name)
            except BadStatusLine:
                connection = KyotoTycoon()
                connection.open(self.host, self.port)
                self.connection = connection
                stored_session = self.connection.get(sid, db=app.name)

            if stored_session:
                return KyotoTycoonSession(initial=stored_session['data'],
                    sid=stored_session['sid'])
        sid = str(uuid4())
        return KyotoTycoonSession(sid=sid)
Example #19
0
 def setUp(self):
     self.kt_handle = KyotoTycoon()
     self.kt_handle.open()
     self.LARGE_KEY_LEN = 8000
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_http_handle = KyotoTycoon(binary=False)
        self.kt_http_handle.open(port=11978)

        self.kt_bin_handle = KyotoTycoon(binary=True)
        self.kt_bin_handle.open(port=11978)

        self.LARGE_KEY_LEN = 8000

    def tearDown(self):
        self.kt_http_handle.close()
        self.kt_bin_handle.close()

    def test_set_expire(self):
        self.assertTrue(self.kt_http_handle.clear())

        # Set record to be expired in 2 seconds.
        self.assertTrue(self.kt_http_handle.set('key1', 'value', 2))
        self.assertEqual(self.kt_http_handle.get('key1'), 'value')
        self.assertEqual(self.kt_http_handle.count(), 1)
        time.sleep(4)
        self.assertEqual(self.kt_http_handle.count(), 0)

        # Bulk expire in 2 seconds.
        self.assertTrue(
            self.kt_http_handle.set_bulk(
                {
                    'key1-1': 'value1',
                    'key1-2': 'value2'
                }, 2))
        self.assertEqual(self.kt_http_handle.get('key1-1'), 'value1')
        self.assertEqual(self.kt_http_handle.get('key1-2'), 'value2')
        self.assertEqual(self.kt_http_handle.count(), 2)
        time.sleep(4)
        self.assertEqual(self.kt_http_handle.count(), 0)

        # Set record to be expired in 2 seconds.
        self.assertTrue(self.kt_bin_handle.set('key2', 'value', 2))
        self.assertEqual(self.kt_bin_handle.get('key2'), 'value')
        self.assertEqual(self.kt_http_handle.count(), 1)
        time.sleep(4)
        self.assertEqual(self.kt_http_handle.count(), 0)

        # Bulk expire in 2 seconds.
        self.assertTrue(
            self.kt_bin_handle.set_bulk(
                {
                    'key2-1': 'value1',
                    'key2-2': 'value2'
                }, 2))
        self.assertEqual(self.kt_bin_handle.get('key2-1'), 'value1')
        self.assertEqual(self.kt_bin_handle.get('key2-2'), 'value2')
        self.assertEqual(self.kt_http_handle.count(), 2)
        time.sleep(4)
        self.assertEqual(self.kt_http_handle.count(), 0)

    def test_add_expire(self):
        self.assertTrue(self.kt_http_handle.clear())

        self.assertTrue(self.kt_http_handle.add('hello', 'world', 2))
        self.assertEqual(self.kt_http_handle.get('hello'), 'world')
        time.sleep(4)
        self.assertEqual(self.kt_http_handle.get('hello'), None)
Example #21
0
 def setUp(self):
     self.kt_handle = KyotoTycoon()
     self.kt_handle.open()
 def setUp(self):
     self.kt_handle = KyotoTycoon()
     self.kt_handle.open(port=11978)
     self.LARGE_KEY_LEN = 8000
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_http_handle = KyotoTycoon(binary=False)
        self.kt_http_handle.open(port=11978)

        self.kt_bin_handle = KyotoTycoon(binary=True)
        self.kt_bin_handle.open(port=11978)

        self.LARGE_KEY_LEN = 8000

    def test_set_expire(self):
        self.assertTrue(self.kt_http_handle.clear())

        # Set record to be expired in 2 seconds.
        self.assertTrue(self.kt_http_handle.set('key1', 'value', 2))
        self.assertEqual(self.kt_http_handle.get('key1'), 'value')
        self.assertEqual(self.kt_http_handle.count(), 1)
        time.sleep(4)
        self.assertEqual(self.kt_http_handle.count(), 0)

        # Bulk expire in 2 seconds.
        self.assertTrue(self.kt_http_handle.set_bulk({'key1-1': 'value1', 'key1-2': 'value2'}, 2))
        self.assertEqual(self.kt_http_handle.get('key1-1'), 'value1')
        self.assertEqual(self.kt_http_handle.get('key1-2'), 'value2')
        self.assertEqual(self.kt_http_handle.count(), 2)
        time.sleep(4)
        self.assertEqual(self.kt_http_handle.count(), 0)

        # Set record to be expired in 2 seconds.
        self.assertTrue(self.kt_bin_handle.set('key2', 'value', 2))
        self.assertEqual(self.kt_bin_handle.get('key2'), 'value')
        self.assertEqual(self.kt_http_handle.count(), 1)
        time.sleep(4)
        self.assertEqual(self.kt_http_handle.count(), 0)

        # Bulk expire in 2 seconds.
        self.assertTrue(self.kt_bin_handle.set_bulk({'key2-1': 'value1', 'key2-2': 'value2'}, 2))
        self.assertEqual(self.kt_bin_handle.get('key2-1'), 'value1')
        self.assertEqual(self.kt_bin_handle.get('key2-2'), 'value2')
        self.assertEqual(self.kt_http_handle.count(), 2)
        time.sleep(4)
        self.assertEqual(self.kt_http_handle.count(), 0)

    def test_add_expire(self):
        self.assertTrue(self.kt_http_handle.clear())

        self.assertTrue(self.kt_http_handle.add('hello', 'world', 2))
        self.assertEqual(self.kt_http_handle.get('hello'), 'world')
        time.sleep(4)
        self.assertEqual(self.kt_http_handle.get('hello'), None)
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open()
        self.LARGE_KEY_LEN = 8000

    def clear_all(self):
        self.assertTrue(self.kt_handle.clear(db=DB_1))
        self.assertTrue(self.kt_handle.clear(db=DB_2))
        return True

    def test_status(self):
        status = self.kt_handle.status(DB_1)
        assert status is not None

        status = self.kt_handle.status(DB_2)
        assert status is not None

        status = self.kt_handle.status(DB_INVALID)
        assert status is None

        status = self.kt_handle.status('non_existent')
        assert status is None

    def test_set_get(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.set('ice', 'cream', db=DB_2))
        self.assertFalse(self.kt_handle.set('palo', 'alto', db=DB_INVALID))

        assert self.kt_handle.get('ice') is None
        assert self.kt_handle.get('ice', db=DB_1) is None
        assert self.kt_handle.get('ice', db=DB_INVALID) is None

        self.assertEqual(self.kt_handle.get('ice', db='two.kch'), 'cream')
        self.assertEqual(self.kt_handle.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle.count(db=DB_2), 1)

        self.assertTrue(self.kt_handle.set('frozen', 'yoghurt', db=DB_1))
        self.assertEqual(self.kt_handle.count(db=DB_1), 1)

        self.assertEqual(self.kt_handle.get('frozen'), 'yoghurt')
        self.assertEqual(self.kt_handle.get('frozen', db=DB_1), 'yoghurt')
        assert self.kt_handle.get('frozen', db=DB_2) is None
        assert self.kt_handle.get('frozen', db=DB_INVALID) is None

        self.assertTrue(self.kt_handle.clear(db=DB_1))
        self.assertEqual(self.kt_handle.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle.count(db=DB_2), 1)

    def test_get_multi(self):
        self.assertTrue(self.clear_all())

        self.assertTrue(self.kt_handle.set('a', 'xxxx', db=DB_1))
        self.assertTrue(self.kt_handle.set('b', 'yyyy', db=DB_1))
        self.assertTrue(self.kt_handle.set('c', 'zzzz', db=DB_1))
        self.assertTrue(self.kt_handle.set('a1', 'xxxx', db=DB_2))
        self.assertTrue(self.kt_handle.set('b1', 'yyyy', db=DB_2))
        self.assertTrue(self.kt_handle.set('c1', 'zzzz', db=DB_2))

        d = self.kt_handle.get_bulk(['a', 'b', 'c'], db=DB_1)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a'], 'xxxx')
        self.assertEqual(d['b'], 'yyyy')
        self.assertEqual(d['c'], 'zzzz')
        d = self.kt_handle.get_bulk(['a', 'b', 'c'], db=DB_2)
        self.assertEqual(len(d), 0)

        d = self.kt_handle.get_bulk(['a1', 'b1', 'c1'], db=DB_2)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a1'], 'xxxx')
        self.assertEqual(d['b1'], 'yyyy')
        self.assertEqual(d['c1'], 'zzzz')
        d = self.kt_handle.get_bulk(['a1', 'b1', 'c1'], db=DB_1)
        self.assertEqual(len(d), 0)

    def test_add(self):
        self.assertTrue(self.clear_all())

        # Should not conflict due to different databases.
        self.assertTrue(self.kt_handle.add('key1', 'val1', db=DB_1))
        self.assertTrue(self.kt_handle.add('key1', 'val1', db=DB_2))

        # Now they should.
        self.assertFalse(self.kt_handle.add('key1', 'val1', db=DB_1))
        self.assertFalse(self.kt_handle.add('key1', 'val1', db=DB_2))
        self.assertFalse(self.kt_handle.add('key1', 'val1', db=DB_INVALID))

    def test_replace(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.add('key1', 'val1', db=DB_1))
        self.assertFalse(self.kt_handle.replace('key1', 'val2', db=DB_2))
        self.assertTrue(self.kt_handle.replace('key1', 'val2', db=DB_1))
        self.assertFalse(self.kt_handle.replace('key1', 'val2', db=DB_INVALID))

        self.assertTrue(self.kt_handle.add('key2', 'aaa'))
        self.assertTrue(self.kt_handle.replace('key2', 'bbb'))
        self.assertTrue(self.kt_handle.replace('key1', 'zzz'))
        self.assertEqual(self.kt_handle.get('key2'), 'bbb')
        self.assertEqual(self.kt_handle.get('key1'), 'zzz')

    def test_cas(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.set('key', 'xxx'))
        self.assertFalse(
            self.kt_handle.cas('key', old_val='xxx', new_val='yyy', db=DB_2))
        self.assertTrue(
            self.kt_handle.cas('key', old_val='xxx', new_val='yyy', db=DB_1))
        self.assertTrue(self.kt_handle.cas('key', new_val='xxx', db=DB_2))

    def test_remove(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.add('key', 'value', db=DB_1))
        self.assertTrue(self.kt_handle.add('key', 'value', db=DB_2))

        self.assertTrue(self.kt_handle.remove('key', db=DB_1))
        self.assertEqual(self.kt_handle.get('key', db=DB_2), 'value')
        assert self.kt_handle.get('key', db=DB_1) is None

    def test_vacuum(self):
        self.assertTrue(self.kt_handle.vacuum())
        self.assertTrue(self.kt_handle.vacuum(db=DB_1))
        self.assertTrue(self.kt_handle.vacuum(db=DB_2))
        self.assertFalse(self.kt_handle.vacuum(db=DB_INVALID))

    def test_append(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.set('key', 'xxx', db=DB_1))
        self.assertTrue(self.kt_handle.set('key', 'xxx', db=DB_2))
        self.assertTrue(self.kt_handle.append('key', 'xxx', db=DB_1))

        self.assertEqual(self.kt_handle.get('key', db=DB_1), 'xxxxxx')
        self.assertEqual(self.kt_handle.get('key', db=DB_2), 'xxx')

    def test_increment(self):
        self.assertTrue(self.clear_all())
        self.assertEqual(self.kt_handle.increment('key', 0, db=DB_1), 0)
        self.assertEqual(self.kt_handle.increment('key', 0, db=DB_2), 0)

        self.assertEqual(self.kt_handle.increment('key', 100, db=DB_1), 100)
        self.assertEqual(self.kt_handle.increment('key', 200, db=DB_2), 200)
        self.assertEqual(self.kt_handle.increment('key', 100, db=DB_1), 200)
        self.assertEqual(self.kt_handle.increment('key', 200, db=DB_2), 400)
        self.assertEqual(self.kt_handle.get_int('key', db=DB_1), 200)
        self.assertEqual(self.kt_handle.get_int('key', db=DB_2), 400)

    def test_match_prefix(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.set('abcdef', 'val', db=DB_1))
        self.assertTrue(self.kt_handle.set('fedcba', 'val', db=DB_2))

        list = self.kt_handle.match_prefix('abc', db=DB_1)
        self.assertEqual(len(list), 1)
        self.assertEqual(list[0], 'abcdef')
        list = self.kt_handle.match_prefix('abc', db=DB_2)
        self.assertEqual(len(list), 0)
        list = self.kt_handle.match_prefix('fed', db=DB_1)
        self.assertEqual(len(list), 0)
        list = self.kt_handle.match_prefix('fed', db=DB_2)
        self.assertEqual(len(list), 1)
        self.assertEqual(list[0], 'fedcba')
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_bin_handle = KyotoTycoon(binary=True, pack_type=kt_binary.KT_PACKER_CUSTOM,
                                                      custom_packer=CustomPacker())
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False, pack_type=kt_http.KT_PACKER_CUSTOM,
                                                        custom_packer=CustomPacker())
        self.kt_http_handle.open(port=11978)

    def test_packer_bytes(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        self.assertTrue(self.kt_bin_handle.set('key1', 'abc'))
        self.assertEqual(self.kt_bin_handle.get('key1'), 'abc')

        self.assertTrue(self.kt_http_handle.set('key2', 'abcd'))
        self.assertEqual(self.kt_http_handle.get('key2'), 'abcd')

        self.assertTrue(self.kt_http_handle.append('key2', 'xyz'))
        self.assertEqual(self.kt_http_handle.get('key2'), 'abcdxyz')

        self.assertEqual(self.kt_http_handle.count(), 2)
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)
class UnitTest(unittest.TestCase):
    def setUp(self):
        memc_packer = MemcachePacker(gzip_enabled=True, gzip_threshold=10, gzip_flag=1)

        self.kt_bin_handle = KyotoTycoon(binary=True, pack_type=kt_binary.KT_PACKER_CUSTOM,
                                                      custom_packer=memc_packer)
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False, pack_type=kt_http.KT_PACKER_CUSTOM,
                                                        custom_packer=memc_packer)
        self.kt_http_handle.open(port=11978)

    def test_packer_bin(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        # Uncompressed
        self.assertTrue(self.kt_bin_handle.set('key1-1', b'12345'))
        self.assertEqual(self.kt_bin_handle.get('key1-1'), b'12345')

        # Compressed
        self.assertTrue(self.kt_bin_handle.set('key1-2', b'12345678901234567890'))
        self.assertEqual(self.kt_bin_handle.get('key1-2'), b'12345678901234567890')

        self.assertEqual(self.kt_http_handle.count(), 2)
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

    def test_packer_http(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        # Uncompressed
        self.assertTrue(self.kt_http_handle.set('key2-1', b'12345'))
        self.assertEqual(self.kt_http_handle.get('key2-1'), b'12345')

        # Compressed
        self.assertTrue(self.kt_http_handle.set('key2-2', b'12345678901234567890'))
        self.assertEqual(self.kt_http_handle.get('key2-2'), b'12345678901234567890')

        self.assertEqual(self.kt_http_handle.count(), 2)
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)
 def connect(self, **kwargs):
     self.conn=KyotoTycoon(binary=False)
     self.conn.open(**kwargs)
 def setUp(self):
     self.kt_handle = KyotoTycoon()
     self.kt_handle.open('tiger')
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle_http = KyotoTycoon(binary=False)
        self.kt_handle_http.open(port=11978)

        self.kt_handle_bin = KyotoTycoon(binary=True)
        self.kt_handle_bin.open(port=11978)

        self.LARGE_KEY_LEN = 8000

    def tearDown(self):
        self.kt_handle_http.close()
        self.kt_handle_bin.close()

    def clear_all(self):
        self.assertTrue(self.kt_handle_http.clear(db=DB_1))
        self.assertTrue(self.kt_handle_http.clear(db=DB_2))
        return True

    def test_status(self):
        status = self.kt_handle_http.status(DB_1)
        assert status is not None

        status = self.kt_handle_http.status(DB_2)
        assert status is not None

        self.assertRaises(KyotoTycoonException, self.kt_handle_http.status,
                          DB_INVALID)
        self.assertRaises(KyotoTycoonException, self.kt_handle_http.status,
                          'non_existent')

    def test_set_get(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.set('ice', 'cream', db=DB_2))
        self.assertRaises(KyotoTycoonException,
                          self.kt_handle_http.set,
                          'palo',
                          'alto',
                          db=DB_INVALID)

        self.assertEqual(self.kt_handle_http.get('ice'), None)
        self.assertEqual(self.kt_handle_http.get('ice', db=DB_1), None)
        self.assertRaises(KyotoTycoonException,
                          self.kt_handle_http.get,
                          'ice',
                          db=DB_INVALID)

        self.assertEqual(self.kt_handle_http.get('ice', db=DB_2), 'cream')
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle_http.count(db=DB_2), 1)

        self.assertTrue(self.kt_handle_http.set('frozen', 'yoghurt', db=DB_1))
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 1)

        self.assertEqual(self.kt_handle_http.get('frozen'), 'yoghurt')
        self.assertEqual(self.kt_handle_http.get('frozen', db=DB_1), 'yoghurt')
        self.assertEqual(self.kt_handle_http.get('frozen', db=DB_2), None)
        self.assertRaises(KyotoTycoonException,
                          self.kt_handle_http.get,
                          'frozen',
                          db=DB_INVALID)

        self.assertTrue(self.kt_handle_http.clear(db=DB_1))
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle_http.count(db=DB_2), 1)

    def test_get_multi(self):
        self.assertTrue(self.clear_all())

        self.assertTrue(self.kt_handle_http.set('a', 'xxxx', db=DB_1))
        self.assertTrue(
            self.kt_handle_http.set_bulk({
                'b': 'yyyy',
                'c': 'zzzz'
            }, db=DB_1))
        self.assertTrue(self.kt_handle_http.set('a1', 'xxxx', db=DB_2))
        self.assertTrue(
            self.kt_handle_http.set_bulk({
                'b1': 'yyyy',
                'c1': 'zzzz'
            }, db=DB_2))

        d = self.kt_handle_http.get_bulk(['a', 'b', 'c'], db=DB_1)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a'], 'xxxx')
        self.assertEqual(d['b'], 'yyyy')
        self.assertEqual(d['c'], 'zzzz')
        d = self.kt_handle_http.get_bulk(['a', 'b', 'c'], db=DB_2)
        self.assertEqual(len(d), 0)

        d = self.kt_handle_http.get_bulk(['a1', 'b1', 'c1'], db=DB_2)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a1'], 'xxxx')
        self.assertEqual(d['b1'], 'yyyy')
        self.assertEqual(d['c1'], 'zzzz')
        d = self.kt_handle_http.get_bulk(['a1', 'b1', 'c1'], db=DB_1)
        self.assertEqual(len(d), 0)

    def test_add(self):
        self.assertTrue(self.clear_all())

        # Should not conflict due to different databases.
        self.assertTrue(self.kt_handle_http.add('key1', 'val1', db=DB_1))
        self.assertTrue(self.kt_handle_http.add('key1', 'val1', db=DB_2))

        # Now they should.
        self.assertRaises(KyotoTycoonException,
                          self.kt_handle_http.add,
                          'key1',
                          'val1',
                          db=DB_1)
        self.assertRaises(KyotoTycoonException,
                          self.kt_handle_http.add,
                          'key1',
                          'val1',
                          db=DB_2)
        self.assertRaises(KyotoTycoonException,
                          self.kt_handle_http.add,
                          'key1',
                          'val1',
                          db=DB_INVALID)

    def test_check(self):
        self.assertTrue(self.kt_handle_http.set('check1', 'abc', db=DB_2))
        self.assertTrue(self.kt_handle_http.check('check1', db=DB_2))
        self.assertFalse(self.kt_handle_http.check('check1', db=DB_1))

    def test_seize(self):
        self.assertTrue(self.kt_handle_http.set('seize1', 'abc', db=DB_2))
        self.assertEqual(self.kt_handle_http.get('seize1', db=DB_2), 'abc')
        self.assertEqual(self.kt_handle_http.get('seize1', db=DB_1), None)
        self.assertEqual(self.kt_handle_http.seize('seize1', db=DB_2), 'abc')
        self.assertEqual(self.kt_handle_http.get('seize1', db=DB_2), None)

    def test_replace(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.add('key1', 'val1', db=DB_1))
        self.assertFalse(self.kt_handle_http.replace('key1', 'val2', db=DB_2))
        self.assertTrue(self.kt_handle_http.replace('key1', 'val2', db=DB_1))
        self.assertFalse(
            self.kt_handle_http.replace('key1', 'val2', db=DB_INVALID))

        self.assertTrue(self.kt_handle_http.add('key2', 'aaa'))
        self.assertTrue(self.kt_handle_http.replace('key2', 'bbb'))
        self.assertTrue(self.kt_handle_http.replace('key1', 'zzz'))
        self.assertEqual(self.kt_handle_http.get('key2'), 'bbb')
        self.assertEqual(self.kt_handle_http.get('key1'), 'zzz')

    def test_cas(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.set('key', 'xxx'))
        self.assertEqual(self.kt_handle_http.get('key', db=DB_2), None)
        self.assertRaises(KyotoTycoonException,
                          self.kt_handle_http.cas,
                          'key',
                          old_val='xxx',
                          new_val='yyy',
                          db=DB_2)
        self.assertEqual(self.kt_handle_http.get('key', db=DB_1), 'xxx')
        self.assertTrue(
            self.kt_handle_http.cas('key',
                                    old_val='xxx',
                                    new_val='yyy',
                                    db=DB_1))
        self.assertTrue(self.kt_handle_http.cas('key', new_val='xxx', db=DB_2))

    def test_remove(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.add('key', 'value', db=DB_1))
        self.assertTrue(self.kt_handle_http.add('key', 'value', db=DB_2))

        self.assertTrue(self.kt_handle_http.remove('key', db=DB_1))
        self.assertEqual(self.kt_handle_http.get('key', db=DB_2), 'value')
        assert self.kt_handle_http.get('key', db=DB_1) is None

    def test_vacuum(self):
        self.assertTrue(self.kt_handle_http.vacuum())
        self.assertTrue(self.kt_handle_http.vacuum(db=DB_1))
        self.assertTrue(self.kt_handle_http.vacuum(db=DB_2))
        self.assertRaises(KyotoTycoonException,
                          self.kt_handle_http.vacuum,
                          db=DB_INVALID)

    def test_append(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.set('key', 'xxx', db=DB_1))
        self.assertTrue(self.kt_handle_http.set('key', 'xxx', db=DB_2))
        self.assertTrue(self.kt_handle_http.append('key', 'xxx', db=DB_1))

        self.assertEqual(self.kt_handle_http.get('key', db=DB_1), 'xxxxxx')
        self.assertEqual(self.kt_handle_http.get('key', db=DB_2), 'xxx')

    def test_increment(self):
        self.assertTrue(self.clear_all())
        self.assertEqual(self.kt_handle_http.increment('key', 0, db=DB_1), 0)
        self.assertEqual(self.kt_handle_http.increment('key', 0, db=DB_2), 0)

        self.assertEqual(self.kt_handle_http.increment('key', 100, db=DB_1),
                         100)
        self.assertEqual(self.kt_handle_http.increment('key', 200, db=DB_2),
                         200)
        self.assertEqual(self.kt_handle_http.increment('key', 100, db=DB_1),
                         200)
        self.assertEqual(self.kt_handle_http.increment('key', 200, db=DB_2),
                         400)
        self.assertEqual(self.kt_handle_http.get_int('key', db=DB_1), 200)
        self.assertEqual(self.kt_handle_http.get_int('key', db=DB_2), 400)

    def test_match_prefix(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.set('abcdef', 'val', db=DB_1))
        self.assertTrue(self.kt_handle_http.set('fedcba', 'val', db=DB_2))

        list = self.kt_handle_http.match_prefix('abc', db=DB_1)
        self.assertEqual(len(list), 1)
        self.assertEqual(list[0], 'abcdef')
        list = self.kt_handle_http.match_prefix('abc', db=DB_2)
        self.assertEqual(len(list), 0)
        list = self.kt_handle_http.match_prefix('fed', db=DB_1)
        self.assertEqual(len(list), 0)
        list = self.kt_handle_http.match_prefix('fed', db=DB_2)
        self.assertEqual(len(list), 1)
        self.assertEqual(list[0], 'fedcba')

    def test_set_get_bin(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_bin.set('ice', 'cream', db=DB_2))
        self.assertFalse(self.kt_handle_bin.set('palo', 'alto', db=DB_INVALID))

        self.assertEqual(self.kt_handle_bin.get('ice'), None)
        self.assertEqual(self.kt_handle_bin.get('ice', db=DB_1), None)
        self.assertFalse(self.kt_handle_bin.get('ice', db=DB_INVALID))

        self.assertEqual(self.kt_handle_bin.get('ice', db=DB_2), 'cream')
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle_http.count(db=DB_2), 1)

        self.assertTrue(self.kt_handle_bin.set('frozen', 'yoghurt', db=DB_1))
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 1)

        self.assertEqual(self.kt_handle_bin.get('frozen'), 'yoghurt')
        self.assertEqual(self.kt_handle_bin.get('frozen', db=DB_1), 'yoghurt')
        self.assertEqual(self.kt_handle_bin.get('frozen', db=DB_2), None)
        self.assertFalse(self.kt_handle_bin.get('frozen', db=DB_INVALID), None)

        self.assertTrue(self.kt_handle_http.clear(db=DB_1))
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle_http.count(db=DB_2), 1)

    def test_get_multi_bin(self):
        self.assertTrue(self.clear_all())

        self.assertTrue(self.kt_handle_bin.set('a', 'xxxx', db=DB_1))
        self.assertTrue(
            self.kt_handle_bin.set_bulk({
                'b': 'yyyy',
                'c': 'zzzz'
            }, db=DB_1))
        self.assertTrue(self.kt_handle_bin.set('a1', 'xxxx', db=DB_2))
        self.assertTrue(
            self.kt_handle_bin.set_bulk({
                'b1': 'yyyy',
                'c1': 'zzzz'
            }, db=DB_2))

        d = self.kt_handle_bin.get_bulk(['a', 'b', 'c'], db=DB_1, atomic=False)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a'], 'xxxx')
        self.assertEqual(d['b'], 'yyyy')
        self.assertEqual(d['c'], 'zzzz')
        d = self.kt_handle_bin.get_bulk(['a', 'b', 'c'], db=DB_2, atomic=False)
        self.assertEqual(len(d), 0)

        d = self.kt_handle_bin.get_bulk(['a1', 'b1', 'c1'],
                                        db=DB_2,
                                        atomic=False)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a1'], 'xxxx')
        self.assertEqual(d['b1'], 'yyyy')
        self.assertEqual(d['c1'], 'zzzz')
        d = self.kt_handle_bin.get_bulk(['a1', 'b1', 'c1'],
                                        db=DB_1,
                                        atomic=False)
        self.assertEqual(len(d), 0)

    def test_remove_bin(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_bin.set('key', 'value', db=DB_1))
        self.assertTrue(self.kt_handle_bin.set('key', 'value', db=DB_2))

        self.assertTrue(self.kt_handle_bin.remove('key', db=DB_1))
        self.assertEqual(self.kt_handle_bin.get('key', db=DB_2), 'value')
        assert self.kt_handle_bin.get('key', db=DB_1) is None
    def setUp(self):
        self.kt_bin_handle = KyotoTycoon(binary=True, pack_type=kt_binary.KT_PACKER_BYTES)
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False, pack_type=kt_http.KT_PACKER_BYTES)
        self.kt_http_handle.open(port=11978)
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_bin_handle = KyotoTycoon(binary=True, pack_type=kt_binary.KT_PACKER_BYTES)
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False, pack_type=kt_http.KT_PACKER_BYTES)
        self.kt_http_handle.open(port=11978)

    def test_packer_bytes(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        value1 = bytes([0x00, 0x01, 0x02, 0xff])
        self.assertTrue(self.kt_bin_handle.set('key1', value1))
        value2 = self.kt_bin_handle.get('key1')
        self.assertEqual(value1, value2)
        self.assertEqual(type(value1), type(value2))

        value3 = bytes([0x00, 0x01, 0x03, 0xff])
        self.assertTrue(self.kt_http_handle.set('key2', value3))
        value4 = self.kt_http_handle.get('key2')
        self.assertEqual(value3, value4)
        self.assertEqual(type(value3), type(value4))

        self.assertTrue(self.kt_http_handle.append('key2', 'xyz'))
        self.assertEqual(self.kt_http_handle.get('key2'), value3 + b'xyz')

        self.assertEqual(self.kt_http_handle.count(), 2)
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)
 def setUp(self):
     self.kt_handle = KyotoTycoon(binary=False, pack_type=KT_PACKER_PICKLE)
     self.kt_handle.open(port=11978)
     self.LARGE_KEY_LEN = 8000
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon(binary=False, pack_type=KT_PACKER_PICKLE)
        self.kt_handle.open(port=11978)
        self.LARGE_KEY_LEN = 8000

    def test_set(self):
        self.assertTrue(self.kt_handle.clear())

        self.assertTrue(self.kt_handle.set('key', 'value'))

        self.assertTrue(self.kt_handle.set('k e y', 'v a l u e'))
        self.assertTrue(self.kt_handle.set('k\te\ty', 'tabbed'))

        self.assertEqual(self.kt_handle.get('key'), 'value')
        self.assertEqual(self.kt_handle.get('k e y'), 'v a l u e')
        self.assertEqual(self.kt_handle.get('k\te\ty'), 'tabbed')

        self.assertTrue(self.kt_handle.set('\\key', '\\xxx'))
        self.assertEqual(self.kt_handle.get('\\key'), '\\xxx')
        self.assertEqual(self.kt_handle.count(), 4)

        self.assertTrue(self.kt_handle.set('tabbed\tkey', 'tabbled\tvalue'))
        self.assertTrue(self.kt_handle.get('tabbed\tkey'))

        self.assertTrue(self.kt_handle.set('url1', 'http://github.com'))
        self.assertTrue(self.kt_handle.set('url2', 'https://github.com/'))
        self.assertTrue(self.kt_handle.set('url3', 'https://github.com/blog/'))

        self.assertTrue(self.kt_handle.set('http://github.com', 'url1'))
        self.assertTrue(self.kt_handle.set('https://github.com', 'url2'))
        self.assertTrue(self.kt_handle.set('https://github.com/blog/', 'url3'))

        self.assertEqual(self.kt_handle.get('non_existent'), None)

        self.assertTrue(self.kt_handle.set('cb', 1791))
        self.assertEqual(self.kt_handle.get('cb'), 1791)

        self.assertTrue(self.kt_handle.set('cb', 1791.1226))
        self.assertEqual(self.kt_handle.get('cb'), 1791.1226)

    def test_cas(self):
        self.assertTrue(self.kt_handle.clear())

        self.assertTrue(self.kt_handle.set('key', 'xxx'))
        self.assertTrue(self.kt_handle.cas('key', old_val='xxx', new_val='yyy'))
        self.assertEqual(self.kt_handle.get('key'), 'yyy')

        self.assertTrue(self.kt_handle.cas('key', old_val='yyy'))
        assert self.kt_handle.get('key') is None
        self.assertTrue(self.kt_handle.cas('key', new_val='zzz'))
        self.assertEqual(self.kt_handle.get('key'), 'zzz')

        self.assertRaises(KyotoTycoonException, self.kt_handle.cas, 'key', old_val='foo', new_val='zz')
        self.assertEqual(self.kt_handle.get('key'), 'zzz')

    def test_remove(self):
        self.assertTrue(self.kt_handle.clear())

        self.assertFalse(self.kt_handle.remove('must fail key'))
        self.assertTrue(self.kt_handle.set('deleteable key', 'xxx'))
        self.assertTrue(self.kt_handle.remove('deleteable key'))

    def test_replace(self):
        self.assertTrue(self.kt_handle.clear())

        # Must Fail - Can't replace something that doesn't exist.
        self.assertFalse(self.kt_handle.replace('xxxxxx', 'some value'))

        # Popuate then Replace.
        self.assertTrue(self.kt_handle.set('apple', 'ringo'))
        self.assertTrue(self.kt_handle.replace('apple', 'apfel'))
        self.assertEqual(self.kt_handle.get('apple'), 'apfel')

        self.assertTrue(self.kt_handle.replace('apple', 212))
        self.assertEqual(self.kt_handle.get('apple'), 212)
        self.assertTrue(self.kt_handle.replace('apple', 121))
        self.assertEqual(self.kt_handle.get('apple'), 121)

    def test_append(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('k1', 'abc'))
        self.assertTrue(self.kt_handle.append('k1', 'def'))
        self.assertEqual(self.kt_handle.get('k1'), 'abcdef')

        self.assertTrue(self.kt_handle.append('k2', 'new val'))
        self.assertEqual(self.kt_handle.get('k2'), 'new val')

        self.assertTrue(self.kt_handle.set('k3', 777))

        self.assertTrue(self.kt_handle.set('k4', b'abc'))
        self.assertTrue(self.kt_handle.append('k4', 'abc'))
        self.assertEqual(self.kt_handle.get('k4'), b'abcabc')

        self.assertTrue(self.kt_handle.set('k5', 'abc'))
        self.assertTrue(self.kt_handle.append('k5', b'abc'))
        self.assertEqual(self.kt_handle.get('k5'), 'abcabc')

    def test_add(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('stewie', 'griffin'))

        # Must Fail - Stewie exists
        self.assertRaises(KyotoTycoonException, self.kt_handle.add, 'stewie', 'hopkin')

        # New records
        self.assertTrue(self.kt_handle.add('peter', 'griffin'))
        self.assertTrue(self.kt_handle.add('lois', 'griffin'))
        self.assertTrue(self.kt_handle.add('seth', 'green'))
        self.assertTrue(self.kt_handle.add('nyc', 'new york city'))

        self.assertTrue(self.kt_handle.add('number', 111))
        self.assertEqual(self.kt_handle.get('number'), 111)

    def test_check(self):
        self.assertTrue(self.kt_handle.set('check1', 'abc'))
        self.assertTrue(self.kt_handle.check('check1'))

        self.assertTrue(self.kt_handle.remove('check1'))
        self.assertFalse(self.kt_handle.check('check1'))

    def test_seize(self):
        self.assertTrue(self.kt_handle.set('seize1', 'abc'))
        self.assertEqual(self.kt_handle.get('seize1'), 'abc')
        self.assertEqual(self.kt_handle.seize('seize1'), 'abc')
        self.assertEqual(self.kt_handle.get('seize1'), None)
        self.assertEqual(self.kt_handle.seize('seize2'), None)

    def test_set_bulk(self):
        self.assertTrue(self.kt_handle.clear())

        dict = {
            'k1': 'one',
            'k2': 'two',
            'k3': 'three',
            'k4': 'four',
            'k\n5': 'five',
            'k\t6': 'six',
            'k7': 111
        }

        n = self.kt_handle.set_bulk(dict)
        self.assertEqual(len(dict), n)
        self.assertEqual(self.kt_handle.get('k1'), 'one')
        self.assertEqual(self.kt_handle.get('k2'), 'two')
        self.assertEqual(self.kt_handle.get('k3'), 'three')
        self.assertEqual(self.kt_handle.get('k4'), 'four')
        self.assertEqual(self.kt_handle.get('k\n5'), 'five')
        self.assertEqual(self.kt_handle.get('k\t6'), 'six')
        self.assertEqual(self.kt_handle.get('k7'), 111)

        d = self.kt_handle.get_bulk(['k1', 'k2', 'k3', 'k4',
                                     'k\n5', 'k\t6', 'k7'])

        self.assertEqual(len(d), len(dict))
        self.assertEqual(d, dict)

        self.assertEqual(self.kt_handle.count(), 7)
        n = self.kt_handle.remove_bulk(['k1', 'k2', 'k\t6'])
        self.assertEqual(self.kt_handle.count(), 4)
        n = self.kt_handle.remove_bulk(['k3'], atomic=True)
        self.assertEqual(self.kt_handle.count(), 3)

    def test_get_bulk(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('a', 'one'))
        self.assertTrue(self.kt_handle.set('b', 'two'))
        self.assertTrue(self.kt_handle.set('c', 'three'))
        self.assertTrue(self.kt_handle.set('d', 'four'))

        d = self.kt_handle.get_bulk(['a','b','c','d'])
        assert d is not None

        self.assertEqual(d['a'], 'one')
        self.assertEqual(d['b'], 'two')
        self.assertEqual(d['c'], 'three')
        self.assertEqual(d['d'], 'four')
        self.assertEqual(len(d), 4)

        d = self.kt_handle.get_bulk(['a','x','y','d'])
        self.assertEqual(len(d), 2)
        d = self.kt_handle.get_bulk(['w','x','y','z'])
        self.assertEqual(len(d), 0)
        d = self.kt_handle.get_bulk([])
        self.assertEqual(d, {})

    def test_large_key(self):
        large_key = 'x' * self.LARGE_KEY_LEN
        self.assertTrue(self.kt_handle.set(large_key, 'value'))
        self.assertEqual(self.kt_handle.get(large_key), 'value')

    def test_report(self):
        report = None
        report = self.kt_handle.report()
        assert report is not None

        self.assertTrue(int(report['serv_conn_count']) > 0)

    def test_status(self):
        self.assertTrue(self.kt_handle.clear())
        status = None
        status = self.kt_handle.status()
        assert status is not None

        self.assertTrue(status['count'], 0)
        self.kt_handle.set('red', 'apple')
        self.kt_handle.set('yellow', 'banana')
        self.kt_handle.set('pink', 'peach')
        self.assertTrue(status['count'], 3)

    def test_vacuum(self):
        self.assertTrue(self.kt_handle.vacuum())

    def test_match_prefix(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('abc', 'val'))
        self.assertTrue(self.kt_handle.set('abcd', 'val'))
        self.assertTrue(self.kt_handle.set('abcde', 'val'))
        self.assertTrue(self.kt_handle.set('abcdef', 'val'))
        self.assertTrue(self.kt_handle.set('abcdefg', 'val'))
        self.assertTrue(self.kt_handle.set('abcdefgh', 'val'))

        list = self.kt_handle.match_prefix('abc')
        self.assertEqual(len(list), 6)
        list = self.kt_handle.match_prefix('abcd')
        self.assertEqual(len(list), 5)
        list = self.kt_handle.match_prefix('abc', 1)
        self.assertEqual(list[0][:3], 'abc')
        list = self.kt_handle.match_prefix('abc', 3)
        self.assertEqual(len(list), 3)

    def test_match_regex(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('abc', 'val'))
        self.assertTrue(self.kt_handle.set('abcd', 'val'))
        self.assertTrue(self.kt_handle.set('abcde', 'val'))

        list = self.kt_handle.match_regex('^abc')
        self.assertEqual(len(list), 3)
        list = self.kt_handle.match_regex('^abcd')
        self.assertEqual(len(list), 2)
        list = self.kt_handle.match_regex('e$')
        self.assertEqual(len(list), 1)
        list = self.kt_handle.match_regex('^abc', 2)
        self.assertEqual(len(list), 2)

    def test_match_similar(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('potatoes', 'val'))
        self.assertTrue(self.kt_handle.set('potataes', 'val'))
        self.assertTrue(self.kt_handle.set('patataes', 'val'))

        list = self.kt_handle.match_similar('potatoes', 0)
        self.assertEqual(len(list), 1)
        list = self.kt_handle.match_similar('potatoes', 1)
        self.assertEqual(len(list), 2)
        list = self.kt_handle.match_similar('potatoes', 2)
        self.assertEqual(len(list), 3)
        list = self.kt_handle.match_similar('potatoes', 2, 1)
        self.assertEqual(len(list), 1)

        self.assertTrue(self.kt_handle.set('cafe', 'val'))
        self.assertTrue(self.kt_handle.set(b'caf\xc3'.decode('iso8859-1'), 'val'))
        list = self.kt_handle.match_similar('cafe', 1)
        self.assertEqual(len(list), 2)


    def test_cursor(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertEqual(self.kt_handle.count(), 0)
        self.assertTrue(self.kt_handle.set('abc', 'val'))
        self.assertTrue(self.kt_handle.set('abcd', 'val'))
        self.assertTrue(self.kt_handle.set('abcde', 'val'))
        self.assertEqual(self.kt_handle.count(), 3)

        cur = self.kt_handle.cursor()
        self.assertTrue(cur.jump())
        while True:
            self.assertEqual(cur.get_key()[:3], 'abc')
            self.assertEqual(cur.get_value(), 'val')

            pair = cur.get()
            self.assertEqual(len(pair), 2)
            self.assertEqual(pair[0][:3], 'abc')
            self.assertEqual(pair[1], 'val')

            self.assertTrue(cur.set_value('foo'))
            self.assertEqual(cur.get_value(), 'foo')

            if pair[0] == 'abcd':
                self.assertTrue(cur.remove())
                break

            if not cur.step():
                break

        self.assertTrue(cur.delete())
        self.assertEqual(self.kt_handle.count(), 2)

        self.assertTrue(self.kt_handle.set('zabc', 'val'))
        self.assertTrue(self.kt_handle.set('zabcd', 'val'))
        self.assertTrue(self.kt_handle.set('zabcde', 'val'))
        self.assertEqual(self.kt_handle.count(), 5)

        cur = self.kt_handle.cursor()
        self.assertTrue(cur.jump(key='zabc'))
        while True:
            pair = cur.get()

            if pair[0] == 'zabc':
                dict = cur.seize()
                self.assertEqual(len(dict), 2)
                self.assertEqual(dict['key'][:4], 'zabc')
                self.assertEqual(dict['value'], 'val')

            if not cur.step():
                break

        self.assertTrue(cur.delete())
        self.assertEqual(self.kt_handle.count(), 4)
Example #34
0
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_bin_handle = KyotoTycoon(binary=True,
                                         pack_type=kt_binary.KT_PACKER_CUSTOM,
                                         custom_packer=CustomPacker())
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False,
                                          pack_type=kt_http.KT_PACKER_CUSTOM,
                                          custom_packer=CustomPacker())
        self.kt_http_handle.open(port=11978)

    def tearDown(self):
        self.kt_http_handle.close()
        self.kt_bin_handle.close()

    def test_packer_bytes(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        self.assertTrue(self.kt_bin_handle.set('key1', 'abc'))
        self.assertEqual(self.kt_bin_handle.get('key1'), 'abc')

        self.assertTrue(self.kt_http_handle.set('key2', 'abcd'))
        self.assertEqual(self.kt_http_handle.get('key2'), 'abcd')

        self.assertTrue(self.kt_http_handle.append('key2', 'xyz'))
        self.assertEqual(self.kt_http_handle.get('key2'), 'abcdxyz')

        self.assertEqual(self.kt_http_handle.count(), 2)
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)
    def setUp(self):
        self.kt_http_handle = KyotoTycoon(binary=False)
        self.kt_http_handle.open(port=11978)

        self.kt_bin_handle = KyotoTycoon(binary=True)
        self.kt_bin_handle.open(port=11978)
Example #36
0
 def setUp(self):
     self.kt_handle = KyotoTycoon()
     self.kt_handle.open(port=11978)
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_http_handle = KyotoTycoon(binary=False)
        self.kt_http_handle.open(port=11978)

        self.kt_bin_handle = KyotoTycoon(binary=True)
        self.kt_bin_handle.open(port=11978)

    def tearDown(self):
        self.kt_http_handle.close()
        self.kt_bin_handle.close()

    def test_play_script(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        self.assertEqual(
            self.kt_bin_handle.play_script('echo', {'key1': b'abc'}),
            {'key1': b'abc'})

        self.assertEqual(
            self.kt_bin_handle.play_script('set', {
                'key': b'key2',
                'value': b'abcd'
            }), {})
        out = self.kt_bin_handle.play_script('get', {'key': b'key2'})
        self.assertTrue('value' in out)
        self.assertEqual(out['value'], b'abcd')

        self.assertEqual(
            self.kt_http_handle.play_script('echo', {'key3': b'abc'}),
            {'key3': b'abc'})

        self.assertEqual(
            self.kt_http_handle.play_script('set', {
                'key': b'key4',
                'value': b'abcd'
            }), {})
        out = self.kt_http_handle.play_script('get', {'key': b'key4'})
        self.assertTrue('value' in out)
        self.assertEqual(out['value'], b'abcd')
    def setUp(self):
        self.kt_http_handle = KyotoTycoon(binary=False)
        self.kt_http_handle.open(port=11978)

        self.kt_bin_handle = KyotoTycoon(binary=True)
        self.kt_bin_handle.open(port=11978)
Example #39
0
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon(binary=False, pack_type=KT_PACKER_PICKLE)
        self.kt_handle.open(port=11978)
        self.LARGE_KEY_LEN = 8000

    def tearDown(self):
        self.kt_handle.close()

    def test_set(self):
        self.assertTrue(self.kt_handle.clear())

        self.assertTrue(self.kt_handle.set('key', 'value'))

        self.assertTrue(self.kt_handle.set('k e y', 'v a l u e'))
        self.assertTrue(self.kt_handle.set('k\te\ty', 'tabbed'))

        self.assertEqual(self.kt_handle.get('key'), 'value')
        self.assertEqual(self.kt_handle.get('k e y'), 'v a l u e')
        self.assertEqual(self.kt_handle.get('k\te\ty'), 'tabbed')

        self.assertTrue(self.kt_handle.set('\\key', '\\xxx'))
        self.assertEqual(self.kt_handle.get('\\key'), '\\xxx')
        self.assertEqual(self.kt_handle.count(), 4)

        self.assertTrue(self.kt_handle.set('tabbed\tkey', 'tabbled\tvalue'))
        self.assertTrue(self.kt_handle.get('tabbed\tkey'))

        self.assertTrue(self.kt_handle.set('url1', 'http://github.com'))
        self.assertTrue(self.kt_handle.set('url2', 'https://github.com/'))
        self.assertTrue(self.kt_handle.set('url3', 'https://github.com/blog/'))

        self.assertTrue(self.kt_handle.set('http://github.com', 'url1'))
        self.assertTrue(self.kt_handle.set('https://github.com', 'url2'))
        self.assertTrue(self.kt_handle.set('https://github.com/blog/', 'url3'))

        self.assertEqual(self.kt_handle.get('non_existent'), None)

        self.assertTrue(self.kt_handle.set('cb', 1791))
        self.assertEqual(self.kt_handle.get('cb'), 1791)

        self.assertTrue(self.kt_handle.set('cb', 1791.1226))
        self.assertEqual(self.kt_handle.get('cb'), 1791.1226)

    def test_cas(self):
        self.assertTrue(self.kt_handle.clear())

        self.assertTrue(self.kt_handle.set('key', 'xxx'))
        self.assertTrue(self.kt_handle.cas('key', old_val='xxx',
                                           new_val='yyy'))
        self.assertEqual(self.kt_handle.get('key'), 'yyy')

        self.assertTrue(self.kt_handle.cas('key', old_val='yyy'))
        assert self.kt_handle.get('key') is None
        self.assertTrue(self.kt_handle.cas('key', new_val='zzz'))
        self.assertEqual(self.kt_handle.get('key'), 'zzz')

        self.assertRaises(KyotoTycoonException,
                          self.kt_handle.cas,
                          'key',
                          old_val='foo',
                          new_val='zz')
        self.assertEqual(self.kt_handle.get('key'), 'zzz')

    def test_remove(self):
        self.assertTrue(self.kt_handle.clear())

        self.assertFalse(self.kt_handle.remove('must fail key'))
        self.assertTrue(self.kt_handle.set('deleteable key', 'xxx'))
        self.assertTrue(self.kt_handle.remove('deleteable key'))

    def test_replace(self):
        self.assertTrue(self.kt_handle.clear())

        # Must Fail - Can't replace something that doesn't exist.
        self.assertFalse(self.kt_handle.replace('xxxxxx', 'some value'))

        # Popuate then Replace.
        self.assertTrue(self.kt_handle.set('apple', 'ringo'))
        self.assertTrue(self.kt_handle.replace('apple', 'apfel'))
        self.assertEqual(self.kt_handle.get('apple'), 'apfel')

        self.assertTrue(self.kt_handle.replace('apple', 212))
        self.assertEqual(self.kt_handle.get('apple'), 212)
        self.assertTrue(self.kt_handle.replace('apple', 121))
        self.assertEqual(self.kt_handle.get('apple'), 121)

    def test_append(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('k1', 'abc'))
        self.assertTrue(self.kt_handle.append('k1', 'def'))
        self.assertEqual(self.kt_handle.get('k1'), 'abcdef')

        self.assertTrue(self.kt_handle.append('k2', 'new val'))
        self.assertEqual(self.kt_handle.get('k2'), 'new val')

        self.assertTrue(self.kt_handle.set('k3', 777))

        self.assertTrue(self.kt_handle.set('k4', b'abc'))
        self.assertTrue(self.kt_handle.append('k4', 'abc'))
        self.assertEqual(self.kt_handle.get('k4'), b'abcabc')

        self.assertTrue(self.kt_handle.set('k5', 'abc'))
        self.assertTrue(self.kt_handle.append('k5', b'abc'))
        self.assertEqual(self.kt_handle.get('k5'), 'abcabc')

    def test_add(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('stewie', 'griffin'))

        # Must Fail - Stewie exists
        self.assertRaises(KyotoTycoonException, self.kt_handle.add, 'stewie',
                          'hopkin')

        # New records
        self.assertTrue(self.kt_handle.add('peter', 'griffin'))
        self.assertTrue(self.kt_handle.add('lois', 'griffin'))
        self.assertTrue(self.kt_handle.add('seth', 'green'))
        self.assertTrue(self.kt_handle.add('nyc', 'new york city'))

        self.assertTrue(self.kt_handle.add('number', 111))
        self.assertEqual(self.kt_handle.get('number'), 111)

    def test_check(self):
        self.assertTrue(self.kt_handle.set('check1', 'abc'))
        self.assertTrue(self.kt_handle.check('check1'))

        self.assertTrue(self.kt_handle.remove('check1'))
        self.assertFalse(self.kt_handle.check('check1'))

    def test_seize(self):
        self.assertTrue(self.kt_handle.set('seize1', 'abc'))
        self.assertEqual(self.kt_handle.get('seize1'), 'abc')
        self.assertEqual(self.kt_handle.seize('seize1'), 'abc')
        self.assertEqual(self.kt_handle.get('seize1'), None)
        self.assertEqual(self.kt_handle.seize('seize2'), None)

    def test_set_bulk(self):
        self.assertTrue(self.kt_handle.clear())

        dict = {
            'k1': 'one',
            'k2': 'two',
            'k3': 'three',
            'k4': 'four',
            'k\n5': 'five',
            'k\t6': 'six',
            'k7': 111
        }

        n = self.kt_handle.set_bulk(dict)
        self.assertEqual(len(dict), n)
        self.assertEqual(self.kt_handle.get('k1'), 'one')
        self.assertEqual(self.kt_handle.get('k2'), 'two')
        self.assertEqual(self.kt_handle.get('k3'), 'three')
        self.assertEqual(self.kt_handle.get('k4'), 'four')
        self.assertEqual(self.kt_handle.get('k\n5'), 'five')
        self.assertEqual(self.kt_handle.get('k\t6'), 'six')
        self.assertEqual(self.kt_handle.get('k7'), 111)

        d = self.kt_handle.get_bulk(
            ['k1', 'k2', 'k3', 'k4', 'k\n5', 'k\t6', 'k7'])

        self.assertEqual(len(d), len(dict))
        self.assertEqual(d, dict)

        self.assertEqual(self.kt_handle.count(), 7)
        n = self.kt_handle.remove_bulk(['k1', 'k2', 'k\t6'])
        self.assertEqual(self.kt_handle.count(), 4)
        n = self.kt_handle.remove_bulk(['k3'], atomic=True)
        self.assertEqual(self.kt_handle.count(), 3)

    def test_get_bulk(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('a', 'one'))
        self.assertTrue(self.kt_handle.set('b', 'two'))
        self.assertTrue(self.kt_handle.set('c', 'three'))
        self.assertTrue(self.kt_handle.set('d', 'four'))

        d = self.kt_handle.get_bulk(['a', 'b', 'c', 'd'])
        assert d is not None

        self.assertEqual(d['a'], 'one')
        self.assertEqual(d['b'], 'two')
        self.assertEqual(d['c'], 'three')
        self.assertEqual(d['d'], 'four')
        self.assertEqual(len(d), 4)

        d = self.kt_handle.get_bulk(['a', 'x', 'y', 'd'])
        self.assertEqual(len(d), 2)
        d = self.kt_handle.get_bulk(['w', 'x', 'y', 'z'])
        self.assertEqual(len(d), 0)
        d = self.kt_handle.get_bulk([])
        self.assertEqual(d, {})

    def test_large_key(self):
        large_key = 'x' * self.LARGE_KEY_LEN
        self.assertTrue(self.kt_handle.set(large_key, 'value'))
        self.assertEqual(self.kt_handle.get(large_key), 'value')

    def test_report(self):
        report = None
        report = self.kt_handle.report()
        assert report is not None

        self.assertTrue(int(report['serv_conn_count']) > 0)

    def test_status(self):
        self.assertTrue(self.kt_handle.clear())
        status = None
        status = self.kt_handle.status()
        assert status is not None

        self.assertTrue(status['count'], 0)
        self.kt_handle.set('red', 'apple')
        self.kt_handle.set('yellow', 'banana')
        self.kt_handle.set('pink', 'peach')
        self.assertTrue(status['count'], 3)

    def test_vacuum(self):
        self.assertTrue(self.kt_handle.vacuum())

    def test_match_prefix(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('abc', 'val'))
        self.assertTrue(self.kt_handle.set('abcd', 'val'))
        self.assertTrue(self.kt_handle.set('abcde', 'val'))
        self.assertTrue(self.kt_handle.set('abcdef', 'val'))
        self.assertTrue(self.kt_handle.set('abcdefg', 'val'))
        self.assertTrue(self.kt_handle.set('abcdefgh', 'val'))

        list = self.kt_handle.match_prefix('abc')
        self.assertEqual(len(list), 6)
        list = self.kt_handle.match_prefix('abcd')
        self.assertEqual(len(list), 5)
        list = self.kt_handle.match_prefix('abc', 1)
        self.assertEqual(list[0][:3], 'abc')
        list = self.kt_handle.match_prefix('abc', 3)
        self.assertEqual(len(list), 3)

    def test_match_regex(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('abc', 'val'))
        self.assertTrue(self.kt_handle.set('abcd', 'val'))
        self.assertTrue(self.kt_handle.set('abcde', 'val'))

        list = self.kt_handle.match_regex('^abc')
        self.assertEqual(len(list), 3)
        list = self.kt_handle.match_regex('^abcd')
        self.assertEqual(len(list), 2)
        list = self.kt_handle.match_regex('e$')
        self.assertEqual(len(list), 1)
        list = self.kt_handle.match_regex('^abc', 2)
        self.assertEqual(len(list), 2)

    def test_match_similar(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('potatoes', 'val'))
        self.assertTrue(self.kt_handle.set('potataes', 'val'))
        self.assertTrue(self.kt_handle.set('patataes', 'val'))

        list = self.kt_handle.match_similar('potatoes', 0)
        self.assertEqual(len(list), 1)
        list = self.kt_handle.match_similar('potatoes', 1)
        self.assertEqual(len(list), 2)
        list = self.kt_handle.match_similar('potatoes', 2)
        self.assertEqual(len(list), 3)
        list = self.kt_handle.match_similar('potatoes', 2, 1)
        self.assertEqual(len(list), 1)

        self.assertTrue(self.kt_handle.set('cafe', 'val'))
        self.assertTrue(
            self.kt_handle.set(b'caf\xc3'.decode('iso8859-1'), 'val'))
        list = self.kt_handle.match_similar('cafe', 1)
        self.assertEqual(len(list), 2)

    def test_cursor(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertEqual(self.kt_handle.count(), 0)
        self.assertTrue(self.kt_handle.set('abc', 'val'))
        self.assertTrue(self.kt_handle.set('abcd', 'val'))
        self.assertTrue(self.kt_handle.set('abcde', 'val'))
        self.assertEqual(self.kt_handle.count(), 3)

        cur = self.kt_handle.cursor()
        self.assertTrue(cur.jump())
        while True:
            self.assertEqual(cur.get_key()[:3], 'abc')
            self.assertEqual(cur.get_value(), 'val')

            pair = cur.get()
            self.assertEqual(len(pair), 2)
            self.assertEqual(pair[0][:3], 'abc')
            self.assertEqual(pair[1], 'val')

            self.assertTrue(cur.set_value('foo'))
            self.assertEqual(cur.get_value(), 'foo')

            if pair[0] == 'abcd':
                self.assertTrue(cur.remove())
                break

            if not cur.step():
                break

        self.assertTrue(cur.delete())
        self.assertEqual(self.kt_handle.count(), 2)

        self.assertTrue(self.kt_handle.set('zabc', 'val'))
        self.assertTrue(self.kt_handle.set('zabcd', 'val'))
        self.assertTrue(self.kt_handle.set('zabcde', 'val'))
        self.assertEqual(self.kt_handle.count(), 5)

        cur = self.kt_handle.cursor()
        self.assertTrue(cur.jump(key='zabc'))
        while True:
            pair = cur.get()

            if pair[0] == 'zabc':
                dict = cur.seize()
                self.assertEqual(len(dict), 2)
                self.assertEqual(dict['key'][:4], 'zabc')
                self.assertEqual(dict['value'], 'val')

            if not cur.step():
                break

        self.assertTrue(cur.delete())
        self.assertEqual(self.kt_handle.count(), 4)
Example #40
0
class UnitTest(unittest.TestCase):
    def setUp(self):
        # For operations not supported by the binary protocol, but useful for testing it...
        self.kt_handle_http = KyotoTycoon(binary=False)
        self.kt_handle_http.open(port=11978)

        self.kt_handle = KyotoTycoon(binary=True, pack_type=KT_PACKER_PICKLE)
        self.kt_handle.open(port=11978)
        self.LARGE_KEY_LEN = 8000

    def tearDown(self):
        self.kt_handle.close()
        self.kt_handle_http.close()

    def test_set(self):
        self.assertTrue(self.kt_handle_http.clear())

        self.assertTrue(self.kt_handle.set('key', 'value'))

        self.assertTrue(self.kt_handle.set('k e y', 'v a l u e'))
        self.assertTrue(self.kt_handle.set('k\te\ty', 'tabbed'))

        self.assertEqual(self.kt_handle.get('key'), 'value')
        self.assertEqual(self.kt_handle.get('k e y'), 'v a l u e')
        self.assertEqual(self.kt_handle.get('k\te\ty'), 'tabbed')

        self.assertTrue(self.kt_handle.set('\\key', '\\xxx'))
        self.assertEqual(self.kt_handle.get('\\key'), '\\xxx')
        self.assertEqual(self.kt_handle_http.count(), 4)

        self.assertTrue(self.kt_handle.set('tabbed\tkey', 'tabbled\tvalue'))
        self.assertTrue(self.kt_handle.get('tabbed\tkey'))

        self.assertTrue(self.kt_handle.set('url1', 'http://github.com'))
        self.assertTrue(self.kt_handle.set('url2', 'https://github.com/'))
        self.assertTrue(self.kt_handle.set('url3', 'https://github.com/blog/'))

        self.assertTrue(self.kt_handle.set('http://github.com', 'url1'))
        self.assertTrue(self.kt_handle.set('https://github.com', 'url2'))
        self.assertTrue(self.kt_handle.set('https://github.com/blog/', 'url3'))

        self.assertEqual(self.kt_handle.get('non_existent'), None)

        self.assertTrue(self.kt_handle.set('cb', 1791))
        self.assertEqual(self.kt_handle.get('cb'), 1791)

        self.assertTrue(self.kt_handle.set('cb', 1791.1226))
        self.assertEqual(self.kt_handle.get('cb'), 1791.1226)

    def test_remove(self):
        self.assertTrue(self.kt_handle_http.clear())

        self.assertFalse(self.kt_handle.remove('must fail key'))
        self.assertTrue(self.kt_handle.set('deleteable key', 'xxx'))
        self.assertTrue(self.kt_handle.remove('deleteable key'))

    def test_set_bulk(self):
        self.assertTrue(self.kt_handle_http.clear())

        dict = {
            'k1': 'one',
            'k2': 'two',
            'k3': 'three',
            'k4': 'four',
            'k\n5': 'five',
            'k\t6': 'six',
            'k7': 111
        }

        n = self.kt_handle.set_bulk(dict, atomic=False)
        self.assertEqual(len(dict), n)
        self.assertEqual(self.kt_handle.get('k1'), 'one')
        self.assertEqual(self.kt_handle.get('k2'), 'two')
        self.assertEqual(self.kt_handle.get('k3'), 'three')
        self.assertEqual(self.kt_handle.get('k4'), 'four')
        self.assertEqual(self.kt_handle.get('k\n5'), 'five')
        self.assertEqual(self.kt_handle.get('k\t6'), 'six')
        self.assertEqual(self.kt_handle.get('k7'), 111)

        d = self.kt_handle.get_bulk(
            ['k1', 'k2', 'k3', 'k4', 'k\n5', 'k\t6', 'k7'], atomic=False)

        self.assertEqual(len(d), len(dict))
        self.assertEqual(d, dict)

        self.assertEqual(self.kt_handle_http.count(), 7)
        n = self.kt_handle.remove_bulk(['k1', 'k2', 'k\t6'], atomic=False)
        self.assertEqual(self.kt_handle_http.count(), 4)
        n = self.kt_handle.remove_bulk(['k3'], atomic=False)
        self.assertEqual(self.kt_handle_http.count(), 3)

    def test_get_bulk(self):
        self.assertTrue(self.kt_handle_http.clear())
        self.assertTrue(self.kt_handle.set('a', 'one'))
        self.assertTrue(self.kt_handle.set('b', 'two'))
        self.assertTrue(self.kt_handle.set('c', 'three'))
        self.assertTrue(self.kt_handle.set('d', 'four'))

        d = self.kt_handle.get_bulk(['a', 'b', 'c', 'd'], atomic=False)
        assert d is not None

        self.assertEqual(d['a'], 'one')
        self.assertEqual(d['b'], 'two')
        self.assertEqual(d['c'], 'three')
        self.assertEqual(d['d'], 'four')
        self.assertEqual(len(d), 4)

        d = self.kt_handle.get_bulk(['a', 'x', 'y', 'd'], atomic=False)
        self.assertEqual(len(d), 2)
        d = self.kt_handle.get_bulk(['w', 'x', 'y', 'z'], atomic=False)
        self.assertEqual(len(d), 0)
        d = self.kt_handle.get_bulk([], atomic=False)
        self.assertEqual(d, {})

    def test_large_key(self):
        large_key = 'x' * self.LARGE_KEY_LEN
        self.assertTrue(self.kt_handle.set(large_key, 'value'))
        self.assertEqual(self.kt_handle.get(large_key), 'value')
Example #41
0
from kyototycoon import KyotoTycoon
import sys,time

# sample usage
kt = KyotoTycoon()
kt.open("localhost", 1978)
kt.set("japan:sexy", "tokyo00000ooo")
#build for masks form
cid =0
for i in range(0,100):
         cid +=1
         if not kt.set("mask:"+str(cid)+":maskid", str(cid)) or\
            not kt.set("mask:"+str(cid)+":userid", str(cid)) or\
            not kt.set("mask:"+str(cid)+":boardid", str(cid)) or\
            not kt.set("mask:"+str(cid)+":fileid", str(cid)) or\
            not kt.set("mask:"+str(cid)+":description", str("Mask的内容描述")) or\
            not kt.set("mask:"+str(cid)+":content", str("哇。。阳光暖暖的,好惬意的。")) or\
            not kt.set("mask:"+str(cid)+":ups",bytes(int("100"))) or\
            not kt.set("mask:"+str(cid)+":downs",bytes(int("10"))) or\
            not kt.set("mask:"+str(cid)+":hits",bytes(int("110"))) or\
            not kt.set("mask:"+str(cid)+":order", bytes(cid)) or\
            not kt.set("maks:"+str(cid)+":createdata",str(int(time.time()))) or\
            not kt.set("maks:"+str(cid)+":commentcount","8") or\
            not kt.set("mask:count", "3"):
                  print >>sys.stderr, "set error: " + str(kt.error())

k=kt.get("mask:100:content")
print(str(k,'UTF-8'))
#kt.remove("japan:sexy")
kt.close()
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open(port=11978)
        self.LARGE_KEY_LEN = 8000

    def tearDown(self):
        self.kt_handle.close()

    def test_increment(self):
        self.assertTrue(self.kt_handle.clear())

        key = 'incrkey'
        self.assertEqual(self.kt_handle.increment(key, 10), 10)
        self.assertEqual(self.kt_handle.increment(key, 10), 20)
        self.assertEqual(self.kt_handle.increment(key, 10), 30)
        self.assertEqual(self.kt_handle.increment(key, 10), 40)
        self.assertEqual(self.kt_handle.increment(key, 10), 50)

        # Incrementing against a non numeric value. Must fail.
        self.assertTrue(self.kt_handle.set(key, 'foo'))
        self.assertRaises(KyotoTycoonException, self.kt_handle.increment, key,
                          10)

    def test_increment_double(self):
        self.assertTrue(self.kt_handle.clear())

        key = 'incrkey'
        self.assertEqual(self.kt_handle.increment_double(key, 1.23), 1.23)
        self.assertEqual(self.kt_handle.increment_double(key, 1.11), 2.34)
        self.assertEqual(self.kt_handle.increment_double(key, 0.16), 2.50)
class UnitTest(unittest.TestCase):
    def setUp(self):
        memc_packer = SimpleMemcachePacker()

        self.kt_bin_handle = KyotoTycoon(binary=True,
                                         pack_type=kt_binary.KT_PACKER_CUSTOM,
                                         custom_packer=memc_packer)
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False,
                                          pack_type=kt_http.KT_PACKER_CUSTOM,
                                          custom_packer=memc_packer)
        self.kt_http_handle.open(port=11978)

    def tearDown(self):
        self.kt_http_handle.close()
        self.kt_bin_handle.close()

    def test_packer_bin(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        self.assertTrue(self.kt_bin_handle.set('key1-1', (b'12345', 1234)))
        self.assertEqual(self.kt_bin_handle.get('key1-1'), (b'12345', 1234))

        self.assertRaises(ValueError, self.kt_bin_handle.set, 'key1-2',
                          (b'12345', -1))

        self.assertEqual(self.kt_http_handle.count(), 1)
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

    def test_packer_http(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        self.assertTrue(self.kt_http_handle.set('key2-1', (b'12345', 1234)))
        self.assertEqual(self.kt_http_handle.get('key2-1'), (b'12345', 1234))

        self.assertRaises(ValueError, self.kt_http_handle.set, 'key2-2',
                          (b'12345', -1))

        self.assertEqual(self.kt_http_handle.count(), 1)
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)
Example #44
0
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open()
        self.LARGE_KEY_LEN = 8000

    def clear_all(self):
        self.assertTrue(self.kt_handle.clear(db=DB_1))
        self.assertTrue(self.kt_handle.clear(db=DB_2))
        return True

    def test_status(self):
        status = self.kt_handle.status(DB_1)
        assert status is not None

        status = self.kt_handle.status(DB_2)
        assert status is not None

        status = self.kt_handle.status(DB_INVALID)
        assert status is None

        status = self.kt_handle.status('non_existent')
        assert status is None

    def test_set_get(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.set('ice', 'cream', db=DB_2))
        self.assertFalse(self.kt_handle.set('palo', 'alto', db=DB_INVALID))

        assert self.kt_handle.get('ice') is None
        assert self.kt_handle.get('ice', db=DB_1) is None
        assert self.kt_handle.get('ice', db=DB_INVALID) is None

        self.assertEqual(self.kt_handle.get('ice', db='two.kch'), 'cream')
        self.assertEqual(self.kt_handle.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle.count(db=DB_2), 1)

        self.assertTrue(self.kt_handle.set('frozen', 'yoghurt', db=DB_1))
        self.assertEqual(self.kt_handle.count(db=DB_1), 1)

        self.assertEqual(self.kt_handle.get('frozen'), 'yoghurt')
        self.assertEqual(self.kt_handle.get('frozen', db=DB_1), 'yoghurt')
        assert self.kt_handle.get('frozen', db=DB_2) is None
        assert self.kt_handle.get('frozen', db=DB_INVALID) is None

        self.assertTrue(self.kt_handle.clear(db=DB_1))
        self.assertEqual(self.kt_handle.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle.count(db=DB_2), 1)

    def test_get_multi(self):
        self.assertTrue(self.clear_all())

        self.assertTrue(self.kt_handle.set('a', 'xxxx', db=DB_1))
        self.assertTrue(self.kt_handle.set('b', 'yyyy', db=DB_1))
        self.assertTrue(self.kt_handle.set('c', 'zzzz', db=DB_1))
        self.assertTrue(self.kt_handle.set('a1', 'xxxx', db=DB_2))
        self.assertTrue(self.kt_handle.set('b1', 'yyyy', db=DB_2))
        self.assertTrue(self.kt_handle.set('c1', 'zzzz', db=DB_2))

        d = self.kt_handle.get_bulk(['a', 'b', 'c'], db=DB_1)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a'], 'xxxx')
        self.assertEqual(d['b'], 'yyyy')
        self.assertEqual(d['c'], 'zzzz')
        d = self.kt_handle.get_bulk(['a', 'b', 'c'], db=DB_2)
        self.assertEqual(len(d), 0)

        d = self.kt_handle.get_bulk(['a1', 'b1', 'c1'], db=DB_2)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a1'], 'xxxx')
        self.assertEqual(d['b1'], 'yyyy')
        self.assertEqual(d['c1'], 'zzzz')
        d = self.kt_handle.get_bulk(['a1', 'b1', 'c1'], db=DB_1)
        self.assertEqual(len(d), 0)

    def test_add(self):
        self.assertTrue(self.clear_all())

        # Should not conflict due to different databases.
        self.assertTrue(self.kt_handle.add('key1', 'val1', db=DB_1))
        self.assertTrue(self.kt_handle.add('key1', 'val1', db=DB_2))

        # Now they should.
        self.assertFalse(self.kt_handle.add('key1', 'val1', db=DB_1))
        self.assertFalse(self.kt_handle.add('key1', 'val1', db=DB_2))
        self.assertFalse(self.kt_handle.add('key1', 'val1', db=DB_INVALID))

    def test_replace(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.add('key1', 'val1', db=DB_1))
        self.assertFalse(self.kt_handle.replace('key1', 'val2', db=DB_2))
        self.assertTrue(self.kt_handle.replace('key1', 'val2', db=DB_1))
        self.assertFalse(self.kt_handle.replace('key1', 'val2', db=DB_INVALID))

        self.assertTrue(self.kt_handle.add('key2', 'aaa'))
        self.assertTrue(self.kt_handle.replace('key2', 'bbb'))
        self.assertTrue(self.kt_handle.replace('key1', 'zzz'))
        self.assertEqual(self.kt_handle.get('key2'), 'bbb')
        self.assertEqual(self.kt_handle.get('key1'), 'zzz')

    def test_cas(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.set('key', 'xxx'))
        self.assertFalse(self.kt_handle.cas('key', old_val='xxx',
                                            new_val='yyy', db=DB_2))
        self.assertTrue(self.kt_handle.cas('key', old_val='xxx',
                                            new_val='yyy', db=DB_1))
        self.assertTrue(self.kt_handle.cas('key', new_val='xxx', db=DB_2))

    def test_remove(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.add('key', 'value', db=DB_1))
        self.assertTrue(self.kt_handle.add('key', 'value', db=DB_2))

        self.assertTrue(self.kt_handle.remove('key', db=DB_1))
        self.assertEqual(self.kt_handle.get('key', db=DB_2), 'value')
        assert self.kt_handle.get('key', db=DB_1) is None

    def test_vacuum(self):
        self.assertTrue(self.kt_handle.vacuum())
        self.assertTrue(self.kt_handle.vacuum(db=DB_1))
        self.assertTrue(self.kt_handle.vacuum(db=DB_2))
        self.assertFalse(self.kt_handle.vacuum(db=DB_INVALID))

    def test_append(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.set('key', 'xxx', db=DB_1))
        self.assertTrue(self.kt_handle.set('key', 'xxx', db=DB_2))
        self.assertTrue(self.kt_handle.append('key', 'xxx', db=DB_1))

        self.assertEqual(self.kt_handle.get('key', db=DB_1), 'xxxxxx')
        self.assertEqual(self.kt_handle.get('key', db=DB_2), 'xxx')

    def test_increment(self):
        self.assertTrue(self.clear_all())
        self.assertEqual(self.kt_handle.increment('key', 0, db=DB_1), 0)
        self.assertEqual(self.kt_handle.increment('key', 0, db=DB_2), 0)

        self.assertEqual(self.kt_handle.increment('key', 100, db=DB_1), 100)
        self.assertEqual(self.kt_handle.increment('key', 200, db=DB_2), 200)
        self.assertEqual(self.kt_handle.increment('key', 100, db=DB_1), 200)
        self.assertEqual(self.kt_handle.increment('key', 200, db=DB_2), 400)
        self.assertEqual(self.kt_handle.get_int('key', db=DB_1), 200)
        self.assertEqual(self.kt_handle.get_int('key', db=DB_2), 400)

    def test_match_prefix(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle.set('abcdef', 'val', db=DB_1))
        self.assertTrue(self.kt_handle.set('fedcba', 'val', db=DB_2))

        list = self.kt_handle.match_prefix('abc', db=DB_1)
        self.assertEqual(len(list), 1)
        self.assertEqual(list[0], 'abcdef')
        list = self.kt_handle.match_prefix('abc', db=DB_2)
        self.assertEqual(len(list), 0)
        list = self.kt_handle.match_prefix('fed', db=DB_1)
        self.assertEqual(len(list), 0)
        list = self.kt_handle.match_prefix('fed', db=DB_2)
        self.assertEqual(len(list), 1)
        self.assertEqual(list[0], 'fedcba')
class UnitTest(unittest.TestCase):
    def setUp(self):
        memc_packer = MemcachePacker(gzip_enabled=True,
                                     gzip_threshold=10,
                                     gzip_flag=1)

        self.kt_bin_handle = KyotoTycoon(binary=True,
                                         pack_type=kt_binary.KT_PACKER_CUSTOM,
                                         custom_packer=memc_packer)
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False,
                                          pack_type=kt_http.KT_PACKER_CUSTOM,
                                          custom_packer=memc_packer)
        self.kt_http_handle.open(port=11978)

    def tearDown(self):
        self.kt_http_handle.close()
        self.kt_bin_handle.close()

    def test_packer_bin(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        # Uncompressed
        self.assertTrue(self.kt_bin_handle.set('key1-1', b'12345'))
        self.assertEqual(self.kt_bin_handle.get('key1-1'), b'12345')

        # Compressed
        self.assertTrue(
            self.kt_bin_handle.set('key1-2', b'12345678901234567890'))
        self.assertEqual(self.kt_bin_handle.get('key1-2'),
                         b'12345678901234567890')

        self.assertEqual(self.kt_http_handle.count(), 2)
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

    def test_packer_http(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        # Uncompressed
        self.assertTrue(self.kt_http_handle.set('key2-1', b'12345'))
        self.assertEqual(self.kt_http_handle.get('key2-1'), b'12345')

        # Compressed
        self.assertTrue(
            self.kt_http_handle.set('key2-2', b'12345678901234567890'))
        self.assertEqual(self.kt_http_handle.get('key2-2'),
                         b'12345678901234567890')

        self.assertEqual(self.kt_http_handle.count(), 2)
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open()
        self.LARGE_KEY_LEN = 8000

    def test_set(self):
        self.assertTrue(self.kt_handle.clear())
        error = self.kt_handle.error()

        self.assertTrue(self.kt_handle.set('key', 'value'))
        self.assertEqual(error.code(), error.SUCCESS)

        self.assertTrue(self.kt_handle.set('k e y', 'v a l u e'))
        self.assertTrue(self.kt_handle.set('k\te\ty', 'tabbed'))

        self.assertEqual(self.kt_handle.get('key'), 'value')
        self.assertEqual(self.kt_handle.get('k e y'), 'v a l u e')
        self.assertEqual(self.kt_handle.get('k\te\ty'), 'tabbed')

        self.assertTrue(self.kt_handle.set('\\key', '\\xxx'))
        self.assertEqual(self.kt_handle.get('\\key'), '\\xxx')
        self.assertEqual(self.kt_handle.count(), 4)

        self.assertTrue(self.kt_handle.set('tabbed\tkey', 'tabbled\tvalue'))
        self.assertTrue(self.kt_handle.get('tabbed\tkey'))

        self.assertTrue(self.kt_handle.set('url1', 'http://github.com'))
        self.assertTrue(self.kt_handle.set('url2', 'https://github.com/'))
        self.assertTrue(self.kt_handle.set('url3', 'https://github.com/blog/'))

        self.assertTrue(self.kt_handle.set('http://github.com', 'url1'))
        self.assertTrue(self.kt_handle.set('https://github.com', 'url2'))
        self.assertTrue(self.kt_handle.set('https://github.com/blog/', 'url3'))

        self.assertFalse(self.kt_handle.set(None, 'value'))
        self.assertEqual(error.code(), error.LOGIC)

        self.assertFalse(self.kt_handle.get(None))
        self.assertEqual(error.code(), error.LOGIC)

        self.assertEqual(self.kt_handle.get('non_existent'), None)
        self.assertEqual(error.code(), error.NOTFOUND)

        self.assertTrue(self.kt_handle.set('cb', 1791))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertEqual(self.kt_handle.get('cb'), 1791)
        self.assertEqual(error.code(), error.SUCCESS)

        self.assertTrue(self.kt_handle.set('cb', 1791.1226))
        self.assertEqual(self.kt_handle.get('cb'), 1791.1226)

    def test_cas(self):
        self.assertTrue(self.kt_handle.clear())
        error = self.kt_handle.error()

        self.assertTrue(self.kt_handle.set('key', 'xxx'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertTrue(self.kt_handle.cas('key', old_val='xxx',
                                           new_val='yyy'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertEqual(self.kt_handle.get('key'), 'yyy')
        self.assertEqual(error.code(), error.SUCCESS)

        self.assertTrue(self.kt_handle.cas('key', old_val='yyy'))
        assert self.kt_handle.get('key') is None
        self.assertEqual(error.code(), error.NOTFOUND)
        self.assertTrue(self.kt_handle.cas('key', new_val='zzz'))
        self.assertEqual(self.kt_handle.get('key'), 'zzz')
        self.assertEqual(error.code(), error.SUCCESS)

        self.assertFalse(self.kt_handle.cas('key', old_val='foo',
                                            new_val='zz'))
        self.assertEqual(error.code(), error.EMISC)
        self.assertEqual(self.kt_handle.get('key'), 'zzz')
        self.assertEqual(error.code(), error.SUCCESS)

    def test_remove(self):
        self.assertTrue(self.kt_handle.clear())
        error = self.kt_handle.error()

        self.assertFalse(self.kt_handle.remove('must fail key'))
        self.assertEqual(error.code(), error.NOTFOUND)
        self.assertTrue(self.kt_handle.set('deleteable key', 'xxx'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertTrue(self.kt_handle.remove('deleteable key'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertFalse(self.kt_handle.remove(None))
        self.assertEqual(error.code(), error.LOGIC)

    def test_replace(self):
        self.assertTrue(self.kt_handle.clear())
        error = self.kt_handle.error()

        # Must Fail - Can't replace something that doesn't exist.
        self.assertFalse(self.kt_handle.replace('xxxxxx', 'some value'))
        self.assertEqual(error.code(), error.NOTFOUND)

        # Popuate then Replace.
        self.assertTrue(self.kt_handle.set('apple', 'ringo'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertTrue(self.kt_handle.replace('apple', 'apfel'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertEqual(self.kt_handle.get('apple'), 'apfel')
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertFalse(self.kt_handle.replace(None, 'value'))
        self.assertEqual(error.code(), error.LOGIC)

        self.assertTrue(self.kt_handle.replace('apple', 212))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertEqual(self.kt_handle.get('apple'), 212)
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertTrue(self.kt_handle.replace('apple', 121))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertEqual(self.kt_handle.get('apple'), 121)
        self.assertEqual(error.code(), error.SUCCESS)

    def test_append(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('k1', 'abc'))
        self.assertTrue(self.kt_handle.append('k1', 'def'))
        self.assertEqual(self.kt_handle.get('k1'), 'abcdef')

        self.assertTrue(self.kt_handle.append('k2', 'new val'))
        self.assertEqual(self.kt_handle.get('k2'), 'new val')

        self.assertTrue(self.kt_handle.set('k3', 777))
        self.assertFalse(self.kt_handle.append('k3', 111))

    def test_add(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('stewie', 'griffin'))

        # Must Fail - Stewie exists
        self.assertFalse(self.kt_handle.add('stewie', 'hopkin'))

        # New records
        self.assertTrue(self.kt_handle.add('peter', 'griffin'))
        self.assertTrue(self.kt_handle.add('lois', 'griffin'))
        self.assertTrue(self.kt_handle.add('seth', 'green'))
        self.assertTrue(self.kt_handle.add('nyc', 'new york city'))
        self.assertFalse(self.kt_handle.add(None, 'value'))

        self.assertTrue(self.kt_handle.add('number', 111))
        self.assertEqual(self.kt_handle.get('number'), 111)

    def test_set_bulk(self):
        self.assertTrue(self.kt_handle.clear())

        dict = {
            'k1': 'one',
            'k2': 'two',
            'k3': 'three',
            'k4': 'four',
            'k\n5': 'five',
            'k\t6': 'six',
            'k7': 111
        }

        n = self.kt_handle.set_bulk(dict)
        self.assertEqual(len(dict), n)
        self.assertEqual(self.kt_handle.get('k1'), 'one')
        self.assertEqual(self.kt_handle.get('k2'), 'two')
        self.assertEqual(self.kt_handle.get('k3'), 'three')
        self.assertEqual(self.kt_handle.get('k4'), 'four')
        self.assertEqual(self.kt_handle.get('k\n5'), 'five')
        self.assertEqual(self.kt_handle.get('k\t6'), 'six')
        self.assertEqual(self.kt_handle.get('k7'), 111)

        d = self.kt_handle.get_bulk(
            ['k1', 'k2', 'k3', 'k4', 'k\n5', 'k\t6', 'k7'])

        self.assertEqual(len(d), len(dict))
        self.assertEqual(d, dict)

        self.assertEqual(self.kt_handle.count(), 7)
        n = self.kt_handle.remove_bulk(['k1', 'k2', 'k\t6'])
        self.assertEqual(self.kt_handle.count(), 4)
        n = self.kt_handle.remove_bulk(['k3'], atomic=True)
        self.assertEqual(self.kt_handle.count(), 3)

    def test_get_bulk(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('a', 'one'))
        self.assertTrue(self.kt_handle.set('b', 'two'))
        self.assertTrue(self.kt_handle.set('c', 'three'))
        self.assertTrue(self.kt_handle.set('d', 'four'))

        d = self.kt_handle.get_bulk(['a', 'b', 'c', 'd'])
        assert d is not None

        self.assertEqual(d['a'], 'one')
        self.assertEqual(d['b'], 'two')
        self.assertEqual(d['c'], 'three')
        self.assertEqual(d['d'], 'four')
        self.assertEqual(len(d), 4)

        d = self.kt_handle.get_bulk(['a', 'x', 'y', 'd'])
        self.assertEqual(len(d), 2)
        d = self.kt_handle.get_bulk(['w', 'x', 'y', 'z'])
        self.assertEqual(len(d), 0)
        d = self.kt_handle.get_bulk([])
        self.assertEqual(d, {})

    def test_large_key(self):
        large_key = 'x' * self.LARGE_KEY_LEN
        self.assertTrue(self.kt_handle.set(large_key, 'value'))
        self.assertEqual(self.kt_handle.get(large_key), 'value')

    def test_report(self):
        report = None
        report = self.kt_handle.report()
        assert report is not None

    def test_status(self):
        self.assertTrue(self.kt_handle.clear())
        status = None
        status = self.kt_handle.status()
        assert status is not None

        self.assertTrue(status['count'], 0)
        self.kt_handle.set('red', 'apple')
        self.kt_handle.set('yellow', 'banana')
        self.kt_handle.set('pink', 'peach')
        self.assertTrue(status['count'], 3)

    def test_error(self):
        self.assertTrue(self.kt_handle.clear())
        kt_error = self.kt_handle.error()
        assert kt_error is not None
        self.assertEqual(kt_error.code(), kt_error.SUCCESS)

    def test_vacuum(self):
        self.assertTrue(self.kt_handle.vacuum())

    def test_match_prefix(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('abc', 'val'))
        self.assertTrue(self.kt_handle.set('abcd', 'val'))
        self.assertTrue(self.kt_handle.set('abcde', 'val'))
        self.assertTrue(self.kt_handle.set('abcdef', 'val'))
        self.assertTrue(self.kt_handle.set('abcdefg', 'val'))
        self.assertTrue(self.kt_handle.set('abcdefgh', 'val'))

        list = self.kt_handle.match_prefix('abc')
        self.assertEqual(len(list), 6)
        list = self.kt_handle.match_prefix('abcd')
        self.assertEqual(len(list), 5)
        list = self.kt_handle.match_prefix('abc', 1)
        self.assertEqual(list[0], 'abc')

    def test_match_regex(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('abc', 'val'))
        self.assertTrue(self.kt_handle.set('abcd', 'val'))
        self.assertTrue(self.kt_handle.set('abcde', 'val'))

        list = self.kt_handle.match_regex('^abc')
        self.assertEqual(len(list), 3)
        list = self.kt_handle.match_regex('^abcd')
        self.assertEqual(len(list), 2)
        list = self.kt_handle.match_regex('e$')
        self.assertEqual(len(list), 1)
class KiotoTycoonDocStorage(object):
    """Stores content in on a kyototycoon server.
    """

    def __init__(self, host="127.0.0.1", port=11978):
        self.connect(host=host,port=port)

    def connect(self, **kwargs):
        self.conn=KyotoTycoon(binary=False)
        self.conn.open(**kwargs)

    def clear(self):
        """Removes all records in the storage.
        """
        self.conn.clear()

    def put(self, content):
        m=hashlib.sha256()
        m.update(content)
        key=m.hexdigest()
        self.conn.set(key, content)
        return key

    def get(self, key):
        """Returns a content stored under
        the supplied key.

        Arguments:
        - `key`: Key of a content to be deleted.
        """
        key=self.resolve(key)
        return self.conn.get(key)

    def remove(self, key):
        """Removes a content stored under
        the supplied key

        Arguments:
        - `key`: Key of a content to be deleted.
        """

        key=self.resolve(key)
        self.conn.remove(key)
        return key

    def resolve(self, key):
        """Figure out a content existence stored
        under the supplied key.

        Arguments:
        - `key`: Key of a content to be checked.
        """
        if type(key)!=str:
            key=hexdigest(key)
        if self.conn.check(key):
            return key
        raise KeyError("no such key")

    def begin(self): # FIXME: Does this affect to a throughoutput?
        pass

    def commit(self):
        pass

    def abort(self):
        pass
 def __init__(self, host=KT_DEFAULT_HOST, port=KT_DEFAULT_PORT):
     connection = KyotoTycoon()
     connection.open(host, port)
     self.connection = connection
     self.host = host
     self.port = port
Example #49
0
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open()
        self.LARGE_KEY_LEN = 8000

    def test_set_expire(self):
        self.assertTrue(self.kt_handle.clear())

        # Set record to be expired in 2 seconds.
        self.assertTrue(self.kt_handle.set('key', 'value', 2))
        self.assertEqual(self.kt_handle.get('key'), 'value')
        self.assertEqual(self.kt_handle.count(), 1)

        # Must be expired after 3 seconds.
        time.sleep(3)
        self.assertEqual(self.kt_handle.get('key'), None)
        self.assertEqual(self.kt_handle.count(), 0)

    def test_add_expire(self):
        self.assertTrue(self.kt_handle.clear())

        self.assertTrue(self.kt_handle.add('hello', 'world', 2))
        self.assertEqual(self.kt_handle.get('hello'), 'world')

        time.sleep(3)
        self.assertEqual(self.kt_handle.get('hello'), None)
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle_http = KyotoTycoon(binary=False)
        self.kt_handle_http.open(port=11978)

        self.kt_handle_bin = KyotoTycoon(binary=True)
        self.kt_handle_bin.open(port=11978)

        self.LARGE_KEY_LEN = 8000

    def clear_all(self):
        self.assertTrue(self.kt_handle_http.clear(db=DB_1))
        self.assertTrue(self.kt_handle_http.clear(db=DB_2))
        return True

    def test_status(self):
        status = self.kt_handle_http.status(DB_1)
        assert status is not None

        status = self.kt_handle_http.status(DB_2)
        assert status is not None

        self.assertRaises(KyotoTycoonException, self.kt_handle_http.status, DB_INVALID)
        self.assertRaises(KyotoTycoonException, self.kt_handle_http.status, 'non_existent')

    def test_set_get(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.set('ice', 'cream', db=DB_2))
        self.assertRaises(KyotoTycoonException, self.kt_handle_http.set, 'palo', 'alto', db=DB_INVALID)

        self.assertEqual(self.kt_handle_http.get('ice'), None)
        self.assertEqual(self.kt_handle_http.get('ice', db=DB_1), None)
        self.assertRaises(KyotoTycoonException, self.kt_handle_http.get, 'ice', db=DB_INVALID)

        self.assertEqual(self.kt_handle_http.get('ice', db=DB_2), 'cream')
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle_http.count(db=DB_2), 1)

        self.assertTrue(self.kt_handle_http.set('frozen', 'yoghurt', db=DB_1))
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 1)

        self.assertEqual(self.kt_handle_http.get('frozen'), 'yoghurt')
        self.assertEqual(self.kt_handle_http.get('frozen', db=DB_1), 'yoghurt')
        self.assertEqual(self.kt_handle_http.get('frozen', db=DB_2), None)
        self.assertRaises(KyotoTycoonException, self.kt_handle_http.get, 'frozen', db=DB_INVALID)

        self.assertTrue(self.kt_handle_http.clear(db=DB_1))
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle_http.count(db=DB_2), 1)

    def test_get_multi(self):
        self.assertTrue(self.clear_all())

        self.assertTrue(self.kt_handle_http.set('a', 'xxxx', db=DB_1))
        self.assertTrue(self.kt_handle_http.set_bulk({'b': 'yyyy', 'c': 'zzzz'}, db=DB_1))
        self.assertTrue(self.kt_handle_http.set('a1', 'xxxx', db=DB_2))
        self.assertTrue(self.kt_handle_http.set_bulk({'b1': 'yyyy', 'c1': 'zzzz'}, db=DB_2))

        d = self.kt_handle_http.get_bulk(['a', 'b', 'c'], db=DB_1)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a'], 'xxxx')
        self.assertEqual(d['b'], 'yyyy')
        self.assertEqual(d['c'], 'zzzz')
        d = self.kt_handle_http.get_bulk(['a', 'b', 'c'], db=DB_2)
        self.assertEqual(len(d), 0)

        d = self.kt_handle_http.get_bulk(['a1', 'b1', 'c1'], db=DB_2)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a1'], 'xxxx')
        self.assertEqual(d['b1'], 'yyyy')
        self.assertEqual(d['c1'], 'zzzz')
        d = self.kt_handle_http.get_bulk(['a1', 'b1', 'c1'], db=DB_1)
        self.assertEqual(len(d), 0)

    def test_add(self):
        self.assertTrue(self.clear_all())

        # Should not conflict due to different databases.
        self.assertTrue(self.kt_handle_http.add('key1', 'val1', db=DB_1))
        self.assertTrue(self.kt_handle_http.add('key1', 'val1', db=DB_2))

        # Now they should.
        self.assertRaises(KyotoTycoonException, self.kt_handle_http.add, 'key1', 'val1', db=DB_1)
        self.assertRaises(KyotoTycoonException, self.kt_handle_http.add, 'key1', 'val1', db=DB_2)
        self.assertRaises(KyotoTycoonException, self.kt_handle_http.add, 'key1', 'val1', db=DB_INVALID)

    def test_check(self):
        self.assertTrue(self.kt_handle_http.set('check1', 'abc', db=DB_2))
        self.assertTrue(self.kt_handle_http.check('check1', db=DB_2))
        self.assertFalse(self.kt_handle_http.check('check1', db=DB_1))

    def test_seize(self):
        self.assertTrue(self.kt_handle_http.set('seize1', 'abc', db=DB_2))
        self.assertEqual(self.kt_handle_http.get('seize1', db=DB_2), 'abc')
        self.assertEqual(self.kt_handle_http.get('seize1', db=DB_1), None)
        self.assertEqual(self.kt_handle_http.seize('seize1', db=DB_2), 'abc')
        self.assertEqual(self.kt_handle_http.get('seize1', db=DB_2), None)

    def test_replace(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.add('key1', 'val1', db=DB_1))
        self.assertFalse(self.kt_handle_http.replace('key1', 'val2', db=DB_2))
        self.assertTrue(self.kt_handle_http.replace('key1', 'val2', db=DB_1))
        self.assertFalse(self.kt_handle_http.replace('key1', 'val2', db=DB_INVALID))

        self.assertTrue(self.kt_handle_http.add('key2', 'aaa'))
        self.assertTrue(self.kt_handle_http.replace('key2', 'bbb'))
        self.assertTrue(self.kt_handle_http.replace('key1', 'zzz'))
        self.assertEqual(self.kt_handle_http.get('key2'), 'bbb')
        self.assertEqual(self.kt_handle_http.get('key1'), 'zzz')

    def test_cas(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.set('key', 'xxx'))
        self.assertEqual(self.kt_handle_http.get('key', db=DB_2), None)
        self.assertRaises(KyotoTycoonException, self.kt_handle_http.cas, 'key', old_val='xxx', new_val='yyy', db=DB_2)
        self.assertEqual(self.kt_handle_http.get('key', db=DB_1), 'xxx')
        self.assertTrue(self.kt_handle_http.cas('key', old_val='xxx', new_val='yyy', db=DB_1))
        self.assertTrue(self.kt_handle_http.cas('key', new_val='xxx', db=DB_2))

    def test_remove(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.add('key', 'value', db=DB_1))
        self.assertTrue(self.kt_handle_http.add('key', 'value', db=DB_2))

        self.assertTrue(self.kt_handle_http.remove('key', db=DB_1))
        self.assertEqual(self.kt_handle_http.get('key', db=DB_2), 'value')
        assert self.kt_handle_http.get('key', db=DB_1) is None

    def test_vacuum(self):
        self.assertTrue(self.kt_handle_http.vacuum())
        self.assertTrue(self.kt_handle_http.vacuum(db=DB_1))
        self.assertTrue(self.kt_handle_http.vacuum(db=DB_2))
        self.assertRaises(KyotoTycoonException, self.kt_handle_http.vacuum, db=DB_INVALID)

    def test_append(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.set('key', 'xxx', db=DB_1))
        self.assertTrue(self.kt_handle_http.set('key', 'xxx', db=DB_2))
        self.assertTrue(self.kt_handle_http.append('key', 'xxx', db=DB_1))

        self.assertEqual(self.kt_handle_http.get('key', db=DB_1), 'xxxxxx')
        self.assertEqual(self.kt_handle_http.get('key', db=DB_2), 'xxx')

    def test_increment(self):
        self.assertTrue(self.clear_all())
        self.assertEqual(self.kt_handle_http.increment('key', 0, db=DB_1), 0)
        self.assertEqual(self.kt_handle_http.increment('key', 0, db=DB_2), 0)

        self.assertEqual(self.kt_handle_http.increment('key', 100, db=DB_1), 100)
        self.assertEqual(self.kt_handle_http.increment('key', 200, db=DB_2), 200)
        self.assertEqual(self.kt_handle_http.increment('key', 100, db=DB_1), 200)
        self.assertEqual(self.kt_handle_http.increment('key', 200, db=DB_2), 400)
        self.assertEqual(self.kt_handle_http.get_int('key', db=DB_1), 200)
        self.assertEqual(self.kt_handle_http.get_int('key', db=DB_2), 400)

    def test_match_prefix(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_http.set('abcdef', 'val', db=DB_1))
        self.assertTrue(self.kt_handle_http.set('fedcba', 'val', db=DB_2))

        list = self.kt_handle_http.match_prefix('abc', db=DB_1)
        self.assertEqual(len(list), 1)
        self.assertEqual(list[0], 'abcdef')
        list = self.kt_handle_http.match_prefix('abc', db=DB_2)
        self.assertEqual(len(list), 0)
        list = self.kt_handle_http.match_prefix('fed', db=DB_1)
        self.assertEqual(len(list), 0)
        list = self.kt_handle_http.match_prefix('fed', db=DB_2)
        self.assertEqual(len(list), 1)
        self.assertEqual(list[0], 'fedcba')

    def test_set_get_bin(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_bin.set('ice', 'cream', db=DB_2))
        self.assertFalse(self.kt_handle_bin.set('palo', 'alto', db=DB_INVALID))

        self.assertEqual(self.kt_handle_bin.get('ice'), None)
        self.assertEqual(self.kt_handle_bin.get('ice', db=DB_1), None)
        self.assertFalse(self.kt_handle_bin.get('ice', db=DB_INVALID))

        self.assertEqual(self.kt_handle_bin.get('ice', db=DB_2), 'cream')
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle_http.count(db=DB_2), 1)

        self.assertTrue(self.kt_handle_bin.set('frozen', 'yoghurt', db=DB_1))
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 1)

        self.assertEqual(self.kt_handle_bin.get('frozen'), 'yoghurt')
        self.assertEqual(self.kt_handle_bin.get('frozen', db=DB_1), 'yoghurt')
        self.assertEqual(self.kt_handle_bin.get('frozen', db=DB_2), None)
        self.assertFalse(self.kt_handle_bin.get('frozen', db=DB_INVALID), None)

        self.assertTrue(self.kt_handle_http.clear(db=DB_1))
        self.assertEqual(self.kt_handle_http.count(db=DB_1), 0)
        self.assertEqual(self.kt_handle_http.count(db=DB_2), 1)

    def test_get_multi_bin(self):
        self.assertTrue(self.clear_all())

        self.assertTrue(self.kt_handle_bin.set('a', 'xxxx', db=DB_1))
        self.assertTrue(self.kt_handle_bin.set_bulk({'b': 'yyyy', 'c': 'zzzz'}, db=DB_1))
        self.assertTrue(self.kt_handle_bin.set('a1', 'xxxx', db=DB_2))
        self.assertTrue(self.kt_handle_bin.set_bulk({'b1': 'yyyy', 'c1': 'zzzz'}, db=DB_2))

        d = self.kt_handle_bin.get_bulk(['a', 'b', 'c'], db=DB_1, atomic=False)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a'], 'xxxx')
        self.assertEqual(d['b'], 'yyyy')
        self.assertEqual(d['c'], 'zzzz')
        d = self.kt_handle_bin.get_bulk(['a', 'b', 'c'], db=DB_2, atomic=False)
        self.assertEqual(len(d), 0)

        d = self.kt_handle_bin.get_bulk(['a1', 'b1', 'c1'], db=DB_2, atomic=False)
        self.assertEqual(len(d), 3)
        self.assertEqual(d['a1'], 'xxxx')
        self.assertEqual(d['b1'], 'yyyy')
        self.assertEqual(d['c1'], 'zzzz')
        d = self.kt_handle_bin.get_bulk(['a1', 'b1', 'c1'], db=DB_1, atomic=False)
        self.assertEqual(len(d), 0)

    def test_remove_bin(self):
        self.assertTrue(self.clear_all())
        self.assertTrue(self.kt_handle_bin.set('key', 'value', db=DB_1))
        self.assertTrue(self.kt_handle_bin.set('key', 'value', db=DB_2))

        self.assertTrue(self.kt_handle_bin.remove('key', db=DB_1))
        self.assertEqual(self.kt_handle_bin.get('key', db=DB_2), 'value')
        assert self.kt_handle_bin.get('key', db=DB_1) is None
Example #51
0
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open()
        self.LARGE_KEY_LEN = 8000

    def test_set(self):
        self.assertTrue(self.kt_handle.clear())
        error = self.kt_handle.error()

        self.assertTrue(self.kt_handle.set('key', 'value'))
        self.assertEqual(error.code(), error.SUCCESS)

        self.assertTrue(self.kt_handle.set('k e y', 'v a l u e'))
        self.assertTrue(self.kt_handle.set('k\te\ty', 'tabbed'))

        self.assertEqual(self.kt_handle.get('key'), 'value')
        self.assertEqual(self.kt_handle.get('k e y'), 'v a l u e')
        self.assertEqual(self.kt_handle.get('k\te\ty'), 'tabbed')

        self.assertTrue(self.kt_handle.set('\\key', '\\xxx'))
        self.assertEqual(self.kt_handle.get('\\key'), '\\xxx')
        self.assertEqual(self.kt_handle.count(), 4)

        self.assertTrue(self.kt_handle.set('tabbed\tkey', 'tabbled\tvalue'))
        self.assertTrue(self.kt_handle.get('tabbed\tkey'))

        self.assertTrue(self.kt_handle.set('url1', 'http://github.com'))
        self.assertTrue(self.kt_handle.set('url2', 'https://github.com/'))
        self.assertTrue(self.kt_handle.set('url3', 'https://github.com/blog/'))

        self.assertTrue(self.kt_handle.set('http://github.com', 'url1'))
        self.assertTrue(self.kt_handle.set('https://github.com', 'url2'))
        self.assertTrue(self.kt_handle.set('https://github.com/blog/', 'url3'))

        self.assertFalse(self.kt_handle.set(None, 'value'))
        self.assertEqual(error.code(), error.LOGIC)

        self.assertFalse(self.kt_handle.get(None))
        self.assertEqual(error.code(), error.LOGIC)

        self.assertEqual(self.kt_handle.get('non_existent'), None)
        self.assertEqual(error.code(), error.NOTFOUND)

        self.assertTrue(self.kt_handle.set('cb', 1791))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertEqual(self.kt_handle.get('cb'), 1791)
        self.assertEqual(error.code(), error.SUCCESS)

        self.assertTrue(self.kt_handle.set('cb', 1791.1226))
        self.assertEqual(self.kt_handle.get('cb'), 1791.1226)

    def test_cas(self):
        self.assertTrue(self.kt_handle.clear())
        error = self.kt_handle.error()

        self.assertTrue(self.kt_handle.set('key', 'xxx'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertTrue(self.kt_handle.cas('key', old_val='xxx', new_val='yyy'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertEqual(self.kt_handle.get('key'), 'yyy')
        self.assertEqual(error.code(), error.SUCCESS)

        self.assertTrue(self.kt_handle.cas('key', old_val='yyy'))
        assert self.kt_handle.get('key') is None
        self.assertEqual(error.code(), error.NOTFOUND)
        self.assertTrue(self.kt_handle.cas('key', new_val='zzz'))
        self.assertEqual(self.kt_handle.get('key'), 'zzz')
        self.assertEqual(error.code(), error.SUCCESS)

        self.assertFalse(self.kt_handle.cas('key', old_val='foo', new_val='zz'))
        self.assertEqual(error.code(), error.EMISC)
        self.assertEqual(self.kt_handle.get('key'), 'zzz')
        self.assertEqual(error.code(), error.SUCCESS)

    def test_remove(self):
        self.assertTrue(self.kt_handle.clear())
        error = self.kt_handle.error()

        self.assertFalse(self.kt_handle.remove('must fail key'))
        self.assertEqual(error.code(), error.NOTFOUND)
        self.assertTrue(self.kt_handle.set('deleteable key', 'xxx'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertTrue(self.kt_handle.remove('deleteable key'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertFalse(self.kt_handle.remove(None))
        self.assertEqual(error.code(), error.LOGIC)

    def test_replace(self):
        self.assertTrue(self.kt_handle.clear())
        error = self.kt_handle.error()

        # Must Fail - Can't replace something that doesn't exist.
        self.assertFalse(self.kt_handle.replace('xxxxxx', 'some value'))
        self.assertEqual(error.code(), error.NOTFOUND)

        # Popuate then Replace.
        self.assertTrue(self.kt_handle.set('apple', 'ringo'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertTrue(self.kt_handle.replace('apple', 'apfel'))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertEqual(self.kt_handle.get('apple'), 'apfel')
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertFalse(self.kt_handle.replace(None, 'value'))
        self.assertEqual(error.code(), error.LOGIC)

        self.assertTrue(self.kt_handle.replace('apple', 212))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertEqual(self.kt_handle.get('apple'), 212)
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertTrue(self.kt_handle.replace('apple', 121))
        self.assertEqual(error.code(), error.SUCCESS)
        self.assertEqual(self.kt_handle.get('apple'), 121)
        self.assertEqual(error.code(), error.SUCCESS)

    def test_append(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('k1', 'abc'))
        self.assertTrue(self.kt_handle.append('k1', 'def'))
        self.assertEqual(self.kt_handle.get('k1'), 'abcdef')

        self.assertTrue(self.kt_handle.append('k2', 'new val'))
        self.assertEqual(self.kt_handle.get('k2'), 'new val')

        self.assertTrue(self.kt_handle.set('k3', 777))
        self.assertFalse(self.kt_handle.append('k3', 111))

    def test_add(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('stewie', 'griffin'))

        # Must Fail - Stewie exists
        self.assertFalse(self.kt_handle.add('stewie', 'hopkin'))

        # New records
        self.assertTrue(self.kt_handle.add('peter', 'griffin'))
        self.assertTrue(self.kt_handle.add('lois', 'griffin'))
        self.assertTrue(self.kt_handle.add('seth', 'green'))
        self.assertTrue(self.kt_handle.add('nyc', 'new york city'))
        self.assertFalse(self.kt_handle.add(None, 'value'))

        self.assertTrue(self.kt_handle.add('number', 111))
        self.assertEqual(self.kt_handle.get('number'), 111)

    def test_set_bulk(self):
        self.assertTrue(self.kt_handle.clear())

        dict = {
            'k1': 'one',
            'k2': 'two',
            'k3': 'three',
            'k4': 'four',
            'k\n5': 'five',
            'k\t6': 'six',
            'k7': 111
        }

        n = self.kt_handle.set_bulk(dict)
        self.assertEqual(len(dict), n)
        self.assertEqual(self.kt_handle.get('k1'), 'one')
        self.assertEqual(self.kt_handle.get('k2'), 'two')
        self.assertEqual(self.kt_handle.get('k3'), 'three')
        self.assertEqual(self.kt_handle.get('k4'), 'four')
        self.assertEqual(self.kt_handle.get('k\n5'), 'five')
        self.assertEqual(self.kt_handle.get('k\t6'), 'six')
        self.assertEqual(self.kt_handle.get('k7'), 111)

        d = self.kt_handle.get_bulk(['k1', 'k2', 'k3', 'k4',
                                     'k\n5', 'k\t6', 'k7'])

        self.assertEqual(len(d), len(dict))
        self.assertEqual(d, dict)

        self.assertEqual(self.kt_handle.count(), 7)
        n = self.kt_handle.remove_bulk(['k1', 'k2', 'k\t6'])
        self.assertEqual(self.kt_handle.count(), 4)
        n = self.kt_handle.remove_bulk(['k3'], atomic=True)
        self.assertEqual(self.kt_handle.count(), 3)

    def test_get_bulk(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('a', 'one'))
        self.assertTrue(self.kt_handle.set('b', 'two'))
        self.assertTrue(self.kt_handle.set('c', 'three'))
        self.assertTrue(self.kt_handle.set('d', 'four'))

        d = self.kt_handle.get_bulk(['a','b','c','d'])
        assert d is not None

        self.assertEqual(d['a'], 'one')
        self.assertEqual(d['b'], 'two')
        self.assertEqual(d['c'], 'three')
        self.assertEqual(d['d'], 'four')
        self.assertEqual(len(d), 4)

        d = self.kt_handle.get_bulk(['a','x','y','d'])
        self.assertEqual(len(d), 2)
        d = self.kt_handle.get_bulk(['w','x','y','z'])
        self.assertEqual(len(d), 0)
        d = self.kt_handle.get_bulk([])
        self.assertEqual(d, {})

    def test_large_key(self):
        large_key = 'x' * self.LARGE_KEY_LEN
        self.assertTrue(self.kt_handle.set(large_key, 'value'))
        self.assertEqual(self.kt_handle.get(large_key), 'value')

    def test_report(self):
        report = None
        report = self.kt_handle.report()
        assert report is not None

    def test_status(self):
        self.assertTrue(self.kt_handle.clear())
        status = None
        status = self.kt_handle.status()
        assert status is not None

        self.assertTrue(status['count'], 0)
        self.kt_handle.set('red', 'apple')
        self.kt_handle.set('yellow', 'banana')
        self.kt_handle.set('pink', 'peach')
        self.assertTrue(status['count'], 3)

    def test_error(self):
        self.assertTrue(self.kt_handle.clear())
        kt_error = self.kt_handle.error()
        assert kt_error is not None
        self.assertEqual(kt_error.code(), kt_error.SUCCESS)

    def test_vacuum(self):
        self.assertTrue(self.kt_handle.vacuum())

    def test_match_prefix(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('abc', 'val'))
        self.assertTrue(self.kt_handle.set('abcd', 'val'))
        self.assertTrue(self.kt_handle.set('abcde', 'val'))
        self.assertTrue(self.kt_handle.set('abcdef', 'val'))
        self.assertTrue(self.kt_handle.set('abcdefg', 'val'))
        self.assertTrue(self.kt_handle.set('abcdefgh', 'val'))

        list = self.kt_handle.match_prefix('abc')
        self.assertEqual(len(list), 6)
        list = self.kt_handle.match_prefix('abcd')
        self.assertEqual(len(list), 5)
        list = self.kt_handle.match_prefix('abc', 1)
        self.assertEqual(list[0], 'abc')

    def test_match_regex(self):
        self.assertTrue(self.kt_handle.clear())
        self.assertTrue(self.kt_handle.set('abc', 'val'))
        self.assertTrue(self.kt_handle.set('abcd', 'val'))
        self.assertTrue(self.kt_handle.set('abcde', 'val'))

        list = self.kt_handle.match_regex('^abc')
        self.assertEqual(len(list), 3)
        list = self.kt_handle.match_regex('^abcd')
        self.assertEqual(len(list), 2)
        list = self.kt_handle.match_regex('e$')
        self.assertEqual(len(list), 1)
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_bin_handle = KyotoTycoon(binary=True,
                                         pack_type=kt_binary.KT_PACKER_BYTES)
        self.kt_bin_handle.open(port=11978)

        self.kt_http_handle = KyotoTycoon(binary=False,
                                          pack_type=kt_http.KT_PACKER_BYTES)
        self.kt_http_handle.open(port=11978)

    def tearDown(self):
        self.kt_http_handle.close()
        self.kt_bin_handle.close()

    def test_packer_bytes(self):
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)

        value1 = bytes([0x00, 0x01, 0x02, 0xff])
        self.assertTrue(self.kt_bin_handle.set('key1', value1))
        value2 = self.kt_bin_handle.get('key1')
        self.assertEqual(value1, value2)
        self.assertEqual(type(value1), type(value2))

        value3 = bytes([0x00, 0x01, 0x03, 0xff])
        self.assertTrue(self.kt_http_handle.set('key2', value3))
        value4 = self.kt_http_handle.get('key2')
        self.assertEqual(value3, value4)
        self.assertEqual(type(value3), type(value4))

        self.assertTrue(self.kt_http_handle.append('key2', 'xyz'))
        self.assertEqual(self.kt_http_handle.get('key2'), value3 + b'xyz')

        self.assertEqual(self.kt_http_handle.count(), 2)
        self.assertTrue(self.kt_http_handle.clear())
        self.assertEqual(self.kt_http_handle.count(), 0)
Example #53
0
File: toto.py Project: ptphp/PyLib
#coding:utf8
#from fdfs import Fdfs
#fs=Fdfs()
#fs.open()
from kyototycoon import KyotoTycoon
k=KyotoTycoon()
k.open()
po=k.set("编解码;编解码","编码编码编码编码编码",60)
print(po)
'''
p=k.remove('jia')
print(p)
'''
p=k.get_str("编解码;编解码")
print(p)
Example #54
0
from kyototycoon import KyotoTycoon
from pyechonest import playlist

import tornado.ioloop
import tornado.web
import tornado.auth

import pymc

from rdio import Rdio

mc = pymc.Client("localhost:11211")
mc.set("foo", "bar")
assert mc.get("foo") == "bar", "memcached not found"

kt = KyotoTycoon()
kt.open(host="localhost", port=1978)
config_dict = json.load(open("snoozaphone.json", "r"))
rdio = Rdio((str(config_dict["RDIO_CONSUMER_KEY"]), str(config_dict["RDIO_CONSUMER_SECRET"])))


class SnoozeAuthHandler(tornado.web.RequestHandler):
    def get_current_user(self):
        user = self.get_secure_cookie("openID_user_email")
        if not user:
            self.write(json.dumps({"user_not_found": True}))
            self.finish()
        else:
            return user

def main():
    server, = parse_args()

    print("Running %d iterations for each parameter..." % NUM_ITERATIONS)

    header = "%-15s | %-16s | %-16s | %-7s | %-14s | %-6s" % \
             ("Binary Protocol", "Unicode Literals", "Packer Type", "Elapsed",
              "Iteration Rate", "Passed")
    print(header)
    print("=" * len(header))

    # Test for both Python 2.x and 3.x...
    unicode_literal = str("") if sys.version_info[0] == 3 else unicode("")
    is_unicode = isinstance("", type(unicode_literal))

    for binary in (True, False):
        for packer_type, packer_name in ((KT_PACKER_PICKLE, "KT_PACKER_PICKLE"),
                                         (KT_PACKER_JSON, "KT_PACKER_JSON"),
                                         (KT_PACKER_STRING, "KT_PACKER_STRING"),
                                         (KT_PACKER_BYTES, "KT_PACKER_BYTES"),
                                         (KT_PACKER_CUSTOM, "MemcachePacker()")):
            if packer_type == KT_PACKER_CUSTOM:
                memc_packer = MemcachePacker(gzip_enabled=False)
                kt = KyotoTycoon(binary=binary, pack_type=KT_PACKER_CUSTOM, custom_packer=memc_packer)
            else:
                kt = KyotoTycoon(binary=binary, pack_type=packer_type)

            with kt.connect(server["host"], server["port"], timeout=2) as db:
                start = time()
                bad = 0

                for i in range(NUM_ITERATIONS):
                    if is_unicode:
                        key = "key-%d-u-%d-%d-café" % (binary, packer_type, i)
                        value = "value-%d-u-%d-%d-café" % (binary, packer_type, i)
                    else:
                        key = "key-%d-s-%d-%d-cafe" % (binary, packer_type, i)
                        value = "value-%d-s-%d-%d-cafe" % (binary, packer_type, i)

                    # In this case we must feed it bytes, and have to encode them...
                    if packer_type in (KT_PACKER_BYTES, KT_PACKER_CUSTOM):
                        value = value.encode("utf-8")

                    db.set(key, value)
                    output = db.get(key)

                    if output != value:
                        bad += 1

                    db.remove(key)
                    output = db.get(key)

                    if output is not None:
                        bad += 1

                duration = time() - start
                rate = NUM_ITERATIONS / duration

                print("%-15s | %-16s | %-16s | %5.2f s | %10.2f ips | %-6s" %
                      (binary, is_unicode, packer_name, duration, rate,
                       "No" if bad > 0 else "Yes"))
Example #56
0
 def setUp(self):
     self.kt_handle = KyotoTycoon(binary=False, pack_type=KT_PACKER_PICKLE)
     self.kt_handle.open(port=11978)
     self.LARGE_KEY_LEN = 8000
 def __init__(self, host=KT_DEFAULT_HOST, port=KT_DEFAULT_PORT):
     connection = KyotoTycoon()
     connection.open(host, port)
     self.connection = connection
     self.host = host
     self.port = port
Example #58
0
def main():
    server, = parse_args()

    print("Running %d iterations for each parameter..." % NUM_ITERATIONS)

    header = "%-15s | %-16s | %-16s | %-7s | %-14s | %-6s" % \
             ("Binary Protocol", "Unicode Literals", "Packer Type", "Elapsed",
              "Iteration Rate", "Passed")
    print(header)
    print("=" * len(header))

    # Test for both Python 2.x and 3.x...
    unicode_literal = str("") if sys.version_info[0] == 3 else unicode("")
    is_unicode = isinstance("", type(unicode_literal))

    for binary in (True, False):
        for packer_type, packer_name in ((KT_PACKER_PICKLE,
                                          "KT_PACKER_PICKLE"),
                                         (KT_PACKER_JSON, "KT_PACKER_JSON"),
                                         (KT_PACKER_STRING,
                                          "KT_PACKER_STRING"),
                                         (KT_PACKER_BYTES, "KT_PACKER_BYTES"),
                                         (KT_PACKER_CUSTOM,
                                          "MemcachePacker()")):
            if packer_type == KT_PACKER_CUSTOM:
                memc_packer = MemcachePacker(gzip_enabled=False)
                kt = KyotoTycoon(binary=binary,
                                 pack_type=KT_PACKER_CUSTOM,
                                 custom_packer=memc_packer)
            else:
                kt = KyotoTycoon(binary=binary, pack_type=packer_type)

            with kt.connect(server["host"], server["port"], timeout=2) as db:
                start = time()
                bad = 0

                for i in range(NUM_ITERATIONS):
                    if is_unicode:
                        key = "key-%d-u-%d-%d-café" % (binary, packer_type, i)
                        value = "value-%d-u-%d-%d-café" % (binary, packer_type,
                                                           i)
                    else:
                        key = "key-%d-s-%d-%d-cafe" % (binary, packer_type, i)
                        value = "value-%d-s-%d-%d-cafe" % (binary, packer_type,
                                                           i)

                    # In this case we must feed it bytes, and have to encode them...
                    if packer_type in (KT_PACKER_BYTES, KT_PACKER_CUSTOM):
                        value = value.encode("utf-8")

                    db.set(key, value)
                    output = db.get(key)

                    if output != value:
                        bad += 1

                    db.remove(key)
                    output = db.get(key)

                    if output is not None:
                        bad += 1

                duration = time() - start
                rate = NUM_ITERATIONS / duration

                print("%-15s | %-16s | %-16s | %5.2f s | %10.2f ips | %-6s" %
                      (binary, is_unicode, packer_name, duration, rate,
                       "No" if bad > 0 else "Yes"))
Example #59
0
class UnitTest(unittest.TestCase):
    def setUp(self):
        self.kt_handle = KyotoTycoon()
        self.kt_handle.open()
        self.LARGE_KEY_LEN = 8000

    def test_set_expire(self):
        self.assertTrue(self.kt_handle.clear())

        # Set record to be expired in 2 seconds.
        self.assertTrue(self.kt_handle.set('key', 'value', 2))
        self.assertEqual(self.kt_handle.get('key'), 'value')
        self.assertEqual(self.kt_handle.count(), 1)

        # Must be expired after 3 seconds.
        time.sleep(3)
        self.assertEqual(self.kt_handle.get('key'), None)
        self.assertEqual(self.kt_handle.count(), 0)

    def test_add_expire(self):
        self.assertTrue(self.kt_handle.clear())

        self.assertTrue(self.kt_handle.add('hello', 'world', 2))
        self.assertEqual(self.kt_handle.get('hello'), 'world')

        time.sleep(3)
        self.assertEqual(self.kt_handle.get('hello'), None)