class RedisStorageTest(StorageTest):
def setUp(self):
self.storage = RedisStorage(Redis())
super(RedisStorageTest, self).setUp()
def test_store_vector(self):
x = numpy.random.randn(100, 1).ravel()
self.check_store_vector(x)
def test_store_sparse_vector(self):
x = scipy.sparse.rand(100, 1, density=0.1)
self.check_store_vector(x)
def test_get_all_bucket_keys(self):
self.check_get_all_bucket_keys()
def test_delete_vector(self):
self.check_delete_vector(numpy.ones(100))
def test_store_zero(self):
x = numpy.ones(100)
hash_name, bucket_name = "tastHash", "testBucket"
self.storage.store_vector(hash_name, bucket_name, x, 0)
bucket = self.storage.get_bucket(hash_name, bucket_name)
_, data = bucket[0]
self.assertEqual(data, 0)
def test_store_many_vectors(self):
x = numpy.random.randn(100, 10)
self.check_store_many_vectors(x)
class RedisStorageTest(StorageTest):
def setUp(self):
self.storage = RedisStorage(Redis())
super(RedisStorageTest, self).setUp()
def test_store_vector(self):
x = numpy.random.randn(100, 1).ravel()
self.check_store_vector(x)
def test_store_sparse_vector(self):
x = scipy.sparse.rand(100, 1, density=0.1)
self.check_store_vector(x)
def test_get_all_bucket_keys(self):
self.check_get_all_bucket_keys()
def test_delete_vector(self):
self.check_delete_vector(numpy.ones(100))
def test_store_zero(self):
x = numpy.ones(100)
hash_name, bucket_name = "tastHash", "testBucket"
self.storage.store_vector(hash_name, bucket_name, x, 0)
bucket = self.storage.get_bucket(hash_name, bucket_name)
_, data = bucket[0]
self.assertEqual(data, 0)
class TestStorage(unittest.TestCase):
def setUp(self):
self.memory = MemoryStorage()
self.redis_object = Redis(host='localhost',
port=6379, db=0)
self.redis_storage = RedisStorage(self.redis_object)
def test_memory_storage(self):
x = numpy.random.randn(100, 1)
bucket_key = '23749283743928748'
x_data = ['one', 'two', 'three']
self.memory.store_vector('testHash', bucket_key, x, x_data)
X = self.memory.get_bucket('testHash', bucket_key)
self.assertEqual(len(X), 1)
y = X[0][0]
y_data = X[0][1]
self.assertEqual(len(y), len(x))
self.assertEqual(type(x), type(y))
for k in range(100):
self.assertEqual(y[k], x[k])
self.assertEqual(type(y_data), type(x_data))
self.assertEqual(len(y_data), len(x_data))
for k in range(3):
self.assertEqual(y_data[k], x_data[k])
self.memory.clean_all_buckets()
self.assertEqual(self.memory.get_bucket('testHash', bucket_key), [])
def test_redis_storage(self):
self.redis_storage.clean_all_buckets()
x = numpy.random.randn(100, 1)
bucket_key = '23749283743928748'
x_data = ['one', 'two', 'three']
self.redis_storage.store_vector('testHash', bucket_key, x, x_data)
X = self.redis_storage.get_bucket('testHash', bucket_key)
self.assertEqual(len(X), 1)
y = X[0][0]
y_data = X[0][1]
self.assertEqual(len(y), len(x))
self.assertEqual(type(x), type(y))
for k in range(100):
self.assertEqual(y[k], x[k])
self.assertEqual(type(y_data), type(x_data))
self.assertEqual(len(y_data), len(x_data))
for k in range(3):
self.assertEqual(y_data[k], x_data[k])
self.redis_storage.clean_all_buckets()
self.assertEqual(self.redis_storage.get_bucket('testHash',
bucket_key), [])
class TestStorage(unittest.TestCase):
def setUp(self):
self.memory = MemoryStorage()
self.redis_object = Redis(host='localhost', port=6379, db=0)
self.redis_storage = RedisStorage(self.redis_object)
def test_memory_storage(self):
x = numpy.random.randn(100, 1)
bucket_key = '23749283743928748'
x_data = ['one', 'two', 'three']
self.memory.store_vector('testHash', bucket_key, x, x_data)
X = self.memory.get_bucket('testHash', bucket_key)
self.assertEqual(len(X), 1)
y = X[0][0]
y_data = X[0][1]
self.assertEqual(len(y), len(x))
self.assertEqual(type(x), type(y))
for k in range(100):
self.assertEqual(y[k], x[k])
self.assertEqual(type(y_data), type(x_data))
self.assertEqual(len(y_data), len(x_data))
for k in range(3):
self.assertEqual(y_data[k], x_data[k])
self.memory.clean_all_buckets()
self.assertEqual(self.memory.get_bucket('testHash', bucket_key), [])
def test_redis_storage(self):
self.redis_storage.clean_all_buckets()
x = numpy.random.randn(100, 1)
bucket_key = '23749283743928748'
x_data = ['one', 'two', 'three']
self.redis_storage.store_vector('testHash', bucket_key, x, x_data)
X = self.redis_storage.get_bucket('testHash', bucket_key)
self.assertEqual(len(X), 1)
y = X[0][0]
y_data = X[0][1]
self.assertEqual(len(y), len(x))
self.assertEqual(type(x), type(y))
for k in range(100):
self.assertEqual(y[k], x[k])
self.assertEqual(type(y_data), type(x_data))
self.assertEqual(len(y_data), len(x_data))
for k in range(3):
self.assertEqual(y_data[k], x_data[k])
self.redis_storage.clean_all_buckets()
self.assertEqual(self.redis_storage.get_bucket('testHash', bucket_key),
[])
class TestStorage(unittest.TestCase):
def setUp(self):
self.memory = MemoryStorage()
self.redis_object = Redis()
self.redis_storage = RedisStorage(self.redis_object)
def test_memory_storage(self):
x = numpy.random.randn(100, 1)
bucket_key = '23749283743928748'
x_data = ['one', 'two', 'three']
self.memory.store_vector('testHash', bucket_key, x, x_data)
X = self.memory.get_bucket('testHash', bucket_key)
self.assertEqual(len(X), 1)
y = X[0][0]
y_data = X[0][1]
self.assertEqual(len(y), len(x))
self.assertEqual(type(x), type(y))
for k in range(100):
self.assertEqual(y[k], x[k])
self.assertEqual(type(y_data), type(x_data))
self.assertEqual(len(y_data), len(x_data))
for k in range(3):
self.assertEqual(y_data[k], x_data[k])
self.memory.clean_all_buckets()
self.assertEqual(self.memory.get_bucket('testHash', bucket_key), [])
def test_redis_storage(self):
self.redis_storage.clean_all_buckets()
x = numpy.random.randn(100, 1)
bucket_key = '23749283743928748'
x_data = ['one', 'two', 'three']
self.redis_storage.store_vector('testHash', bucket_key, x, x_data)
X = self.redis_storage.get_bucket('testHash', bucket_key)
self.assertEqual(len(X), 1)
y = X[0][0]
y_data = X[0][1]
self.assertEqual(len(y), len(x))
self.assertEqual(type(x), type(y))
for k in range(100):
self.assertEqual(y[k], x[k])
self.assertEqual(type(y_data), type(x_data))
self.assertEqual(len(y_data), len(x_data))
for k in range(3):
self.assertEqual(y_data[k], x_data[k])
self.redis_storage.clean_all_buckets()
self.assertEqual(self.redis_storage.get_bucket('testHash',
bucket_key), [])
def test_redis_storage_sparse(self):
self.redis_storage.clean_all_buckets()
x = scipy.sparse.rand(100, 1, density=0.1)
bucket_key = '23749283743928748'
x_data = ['one', 'two', 'three']
self.redis_storage.store_vector('testHash', bucket_key, x, x_data)
X = self.redis_storage.get_bucket('testHash', bucket_key)
self.assertEqual(len(X), 1)
y = X[0][0]
y_data = X[0][1]
self.assertEqual(type(x), type(y))
self.assertEqual(x.shape[0], y.shape[0])
self.assertEqual(x.shape[1], y.shape[1])
self.assertTrue((y - x).sum() == 0.0)
self.assertEqual(type(y_data), type(x_data))
self.assertEqual(len(y_data), len(x_data))
for k in range(3):
self.assertEqual(y_data[k], x_data[k])
self.redis_storage.clean_all_buckets()
self.assertEqual(self.redis_storage.get_bucket('testHash',
bucket_key), [])
class TestStorage(unittest.TestCase):
def setUp(self):
self.memory = MemoryStorage()
self.redis_object = Redis()
self.redis_storage = RedisStorage(self.redis_object)
def test_memory_storage(self):
x = numpy.random.randn(100, 1)
bucket_key = '23749283743928748'
x_data = ['one', 'two', 'three']
self.memory.store_vector('testHash', bucket_key, x, x_data)
X = self.memory.get_bucket('testHash', bucket_key)
self.assertEqual(len(X), 1)
y = X[0][0]
y_data = X[0][1]
self.assertEqual(len(y), len(x))
self.assertEqual(type(x), type(y))
for k in range(100):
self.assertEqual(y[k], x[k])
self.assertEqual(type(y_data), type(x_data))
self.assertEqual(len(y_data), len(x_data))
for k in range(3):
self.assertEqual(y_data[k], x_data[k])
self.memory.clean_all_buckets()
self.assertEqual(self.memory.get_bucket('testHash', bucket_key), [])
def test_redis_storage(self):
self.redis_storage.clean_all_buckets()
x = numpy.random.randn(100, 1)
bucket_key = '23749283743928748'
x_data = ['one', 'two', 'three']
self.redis_storage.store_vector('testHash', bucket_key, x, x_data)
X = self.redis_storage.get_bucket('testHash', bucket_key)
self.assertEqual(len(X), 1)
y = X[0][0]
y_data = X[0][1]
self.assertEqual(len(y), len(x))
self.assertEqual(type(x), type(y))
for k in range(100):
self.assertEqual(y[k], x[k])
self.assertEqual(type(y_data), type(x_data))
self.assertEqual(len(y_data), len(x_data))
for k in range(3):
self.assertEqual(y_data[k], x_data[k])
self.redis_storage.clean_all_buckets()
self.assertEqual(self.redis_storage.get_bucket('testHash', bucket_key),
[])
def test_redis_storage_sparse(self):
self.redis_storage.clean_all_buckets()
x = scipy.sparse.rand(100, 1, density=0.1)
bucket_key = '23749283743928748'
x_data = ['one', 'two', 'three']
self.redis_storage.store_vector('testHash', bucket_key, x, x_data)
X = self.redis_storage.get_bucket('testHash', bucket_key)
self.assertEqual(len(X), 1)
y = X[0][0]
y_data = X[0][1]
self.assertEqual(type(x), type(y))
self.assertEqual(x.shape[0], y.shape[0])
self.assertEqual(x.shape[1], y.shape[1])
self.assertTrue((y - x).sum() == 0.0)
self.assertEqual(type(y_data), type(x_data))
self.assertEqual(len(y_data), len(x_data))
for k in range(3):
self.assertEqual(y_data[k], x_data[k])
self.redis_storage.clean_all_buckets()
self.assertEqual(self.redis_storage.get_bucket('testHash', bucket_key),
[])
