@Test
public void del() {
rc.del(a("key1", "key2", "key3"));
eq("OK", rc.set("key1", "Hello"));
eq("OK", rc.set("key2", "World"));
eq(2, rc.del(a("key1", "key2", "key3")));
}
@Test
public void append() {
rc.del(a("mykey"));
eq(5, rc.append("mykey", "Hello"));
eq(11, rc.append("mykey", " World"));
eq("Hello World", rc.get("mykey"));
}
@Test
public void zcard() {
rc.del(a("myzset"));
eq(1, rc.zadd(a("myzset", "1", "one")));
eq(1, rc.zadd(a("myzset", "2", "two")));
eq(2, rc.zcard("myzset"));
}
@Test
public void exists() {
rc.del_("key1", "key2");
eq("OK", rc.set("key1", "value"));
eq(1, rc.exists("key1"));
eq(0, rc.exists("key2"));
}
@Test
public void zincrby() {
rc.del(a("myzset"));
eq(1, rc.zadd(a("myzset", "1", "one")));
eq(1, rc.zadd(a("myzset", "2", "two")));
eq("3", rc.zincrby("myzset", "2", "one"));
eq(a("two", "2", "one", "3"), rc.zrange("myzset", "0", "-1", WITHSCORES));
}
@Test
public void zrevrank() {
rc.del(a("myzset"));
eq(1, rc.zadd(a("myzset", "1", "one")));
eq(1, rc.zadd(a("myzset", "2", "two")));
eq(1, rc.zadd(a("myzset", "3", "three")));
eq(2, (IntegerReply) rc.zrevrank("myzset", "one"));
eq(null, (BulkReply) rc.zrevrank("myzset", "four"));
}
@Test
public void zremrangebyscore() {
rc.del(a("myzset"));
eq(1, rc.zadd(a("myzset", "1", "one")));
eq(1, rc.zadd(a("myzset", "2", "two")));
eq(1, rc.zadd(a("myzset", "3", "three")));
eq(1, rc.zremrangebyscore("myzset", "-inf", "(2"));
eq(a("two", "2", "three", "3"), rc.zrange("myzset", "0", "-1", WITHSCORES));
}
@Test
public void zrem() {
rc.del(a("myzset"));
eq(1, rc.zadd(a("myzset", "1", "one")));
eq(1, rc.zadd(a("myzset", "2", "two")));
eq(1, rc.zadd(a("myzset", "3", "three")));
eq(1, rc.zrem_("myzset", "two"));
eq(a("one", "1", "three", "3"), rc.zrange("myzset", "0", "-1", WITHSCORES));
}
@Test
public void zcount() {
rc.del(a("myzset"));
eq(1, rc.zadd(a("myzset", "1", "one")));
eq(1, rc.zadd(a("myzset", "2", "two")));
eq(1, rc.zadd(a("myzset", "3", "three")));
eq(3, rc.zcount("myzset", "-inf", "inf"));
eq(2, rc.zcount("myzset", "(1", "3"));
}
@Test
public void decr() {
eq("OK", rc.set("mykey", "10"));
eq(9, rc.decr("mykey"));
eq("OK", rc.set("mykey", "234293482390480948029348230948"));
try {
rc.decr("mykey");
fail("Should have failed");
} catch (RedisException e) {
// failed
}
}
public Object execute(String command, byte[]... args) {
Assert.hasText(command, "a valid command needs to be specified");
try {
String name = command.trim().toUpperCase();
Command cmd = new Command(name.getBytes(Charsets.UTF_8), args);
if (isPipelined()) {
pipeline(client.pipeline(name, cmd));
return null;
} else {
return client.execute(name, cmd);
}
} catch (RedisException ex) {
throw convertSrpAccessException(ex);
}
}
public void select(int dbIndex) {
try {
if (isPipelined()) {
pipeline(pipeline.select(dbIndex));
}
client.select(dbIndex);
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public Long rPush(byte[] key, byte[] value) {
try {
if (isPipelined()) {
pipeline(pipeline.rpush(key, new Object[] {value}));
return null;
}
return client.rpush(key, new Object[] {value}).data();
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public void setRange(byte[] key, byte[] value, long start) {
try {
if (isPipelined()) {
pipeline(pipeline.setrange(key, start, value));
return;
}
client.setrange(key, start, value);
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public Long strLen(byte[] key) {
try {
if (isPipelined()) {
pipeline(pipeline.strlen(key));
return null;
}
return client.strlen(key).data();
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public Boolean getBit(byte[] key, long offset) {
try {
if (isPipelined()) {
pipeline(pipeline.getbit(key, offset));
return null;
}
return (client.getbit(key, offset).data() == 1);
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public void setBit(byte[] key, long offset, boolean value) {
try {
if (isPipelined()) {
pipeline(pipeline.setbit(key, offset, SrpUtils.asBit(value)));
return;
}
client.setbit(key, offset, SrpUtils.asBit(value));
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public Long incrBy(byte[] key, long value) {
try {
if (isPipelined()) {
pipeline(pipeline.incrby(key, value));
return null;
}
return client.incrby(key, value).data();
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public byte[] lIndex(byte[] key, long index) {
try {
if (isPipelined()) {
pipeline(pipeline.lindex(key, index));
return null;
}
return client.lindex(key, index).data();
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public byte[] rPop(byte[] key) {
try {
if (isPipelined()) {
pipeline(pipeline.rpop(key));
return null;
}
return client.rpop(key).data();
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public void lSet(byte[] key, long index, byte[] value) {
try {
if (isPipelined()) {
pipeline(pipeline.lset(key, index, value));
return;
}
client.lset(key, index, value);
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public List<byte[]> lRange(byte[] key, long start, long end) {
try {
if (isPipelined()) {
pipeline(pipeline.lrange(key, start, end));
return null;
}
return SrpUtils.toBytesList(client.lrange(key, start, end).data());
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public Long lInsert(byte[] key, Position where, byte[] pivot, byte[] value) {
try {
if (isPipelined()) {
pipeline(pipeline.linsert(key, SrpUtils.convertPosition(where), pivot, value));
return null;
}
return client.linsert(key, SrpUtils.convertPosition(where), pivot, value).data();
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public void mSetNX(Map<byte[], byte[]> tuples) {
try {
if (isPipelined()) {
pipeline(pipeline.msetnx((Object[]) SrpUtils.convert(tuples)));
return;
}
client.msetnx((Object[]) SrpUtils.convert(tuples));
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public Long lRem(byte[] key, long count, byte[] value) {
try {
if (isPipelined()) {
pipeline(pipeline.lrem(key, count, value));
return null;
}
return client.lrem(key, count, value).data();
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public void setEx(byte[] key, long time, byte[] value) {
try {
if (isPipelined()) {
pipeline(pipeline.setex(key, time, value));
return;
}
client.setex(key, time, value);
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public void lTrim(byte[] key, long start, long end) {
try {
if (isPipelined()) {
pipeline(pipeline.ltrim(key, start, end));
return;
}
client.ltrim(key, start, end);
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public Boolean setNX(byte[] key, byte[] value) {
try {
if (isPipelined()) {
pipeline(pipeline.setnx(key, value));
return null;
}
return client.setnx(key, value).data() == 1;
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public byte[] rPopLPush(byte[] srcKey, byte[] dstKey) {
try {
if (isPipelined()) {
pipeline(pipeline.rpoplpush(srcKey, dstKey));
return null;
}
return client.rpoplpush(srcKey, dstKey).data();
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}
public byte[] getRange(byte[] key, long start, long end) {
try {
if (isPipelined()) {
pipeline(pipeline.getrange(key, start, end));
return null;
}
return client.getrange(key, start, end).data();
} catch (Exception ex) {
throw convertSrpAccessException(ex);
}
}