rik/jlibredis
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge pull request #489 from xetorthio/scan_commands

Browse Source 
add SCAN, HSCAN, SSCAN and ZSCAN
This commit is contained in:
Jonathan Leibiusky
2013-12-03 13:58:41 -08:00
parent efbb710343 a27c67de66
commit 1c8e222655
14 changed files with 862 additions and 497 deletions
Download Patch File Download Diff File Expand all files Collapse all files

31
src/main/java/redis/clients/jedis/BinaryClient.java
View File

@@ -1100,4 +1100,35 @@ public class BinaryClient extends Connection {
public void hincrByFloat(final byte[] key, final byte[] field, double increment) { public void hincrByFloat(final byte[] key, final byte[] field, double increment) {
sendCommand(HINCRBYFLOAT, key, field, toByteArray(increment)); sendCommand(HINCRBYFLOAT, key, field, toByteArray(increment));
} }
public void scan(int cursor, final ScanParams params) {
final List<byte[]> args = new ArrayList<byte[]>();
args.add(toByteArray(cursor));
args.addAll(params.getParams());
sendCommand(SCAN, args.toArray(new byte[args.size()][]));
}
public void hscan(final byte[] key, int cursor, final ScanParams params) {
final List<byte[]> args = new ArrayList<byte[]>();
args.add(key);
args.add(toByteArray(cursor));
args.addAll(params.getParams());
sendCommand(HSCAN, args.toArray(new byte[args.size()][]));
}
public void sscan(final byte[] key, int cursor, final ScanParams params) {
final List<byte[]> args = new ArrayList<byte[]>();
args.add(key);
args.add(toByteArray(cursor));
args.addAll(params.getParams());
sendCommand(SSCAN, args.toArray(new byte[args.size()][]));
}
public void zscan(final byte[] key, int cursor, final ScanParams params) {
final List<byte[]> args = new ArrayList<byte[]>();
args.add(key);
args.add(toByteArray(cursor));
args.addAll(params.getParams());
sendCommand(ZSCAN, args.toArray(new byte[args.size()][]));
}
} }

13
src/main/java/redis/clients/jedis/Client.java
View File

@@ -9,6 +9,7 @@ import java.util.Map;
import java.util.Map.Entry; import java.util.Map.Entry;
import static redis.clients.jedis.Protocol.toByteArray; import static redis.clients.jedis.Protocol.toByteArray;
import static redis.clients.jedis.Protocol.Command.HSCAN;
public class Client extends BinaryClient implements Commands { public class Client extends BinaryClient implements Commands {
public Client(final String host) { public Client(final String host) {
@@ -807,4 +808,16 @@ public class Client extends BinaryClient implements Commands {
public void hincrByFloat(final String key, final String field, double increment) { public void hincrByFloat(final String key, final String field, double increment) {
hincrByFloat(SafeEncoder.encode(key), SafeEncoder.encode(field), increment); hincrByFloat(SafeEncoder.encode(key), SafeEncoder.encode(field), increment);
} }
public void hscan(final String key, int cursor, final ScanParams params) {
hscan(SafeEncoder.encode(key), cursor, params);
}
public void sscan(final String key, int cursor, final ScanParams params) {
sscan(SafeEncoder.encode(key), cursor, params);
}
public void zscan(final String key, int cursor, final ScanParams params) {
zscan(SafeEncoder.encode(key), cursor, params);
}
} }

8
src/main/java/redis/clients/jedis/Commands.java
View File

@@ -295,4 +295,12 @@ public interface Commands {
public void bitcount(final String key, long start, long end); public void bitcount(final String key, long start, long end);
public void bitop(BitOP op, final String destKey, String... srcKeys); public void bitop(BitOP op, final String destKey, String... srcKeys);
public void scan(int cursor, final ScanParams params);
public void hscan(final String key, int cursor, final ScanParams params);
public void sscan(final String key, int cursor, final ScanParams params);
public void zscan(final String key, int cursor, final ScanParams params);
} }

83
src/main/java/redis/clients/jedis/Jedis.java
View File

@@ -1,12 +1,19 @@
package redis.clients.jedis; package redis.clients.jedis;
import java.net.URI;
import java.util.AbstractMap;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import redis.clients.jedis.BinaryClient.LIST_POSITION; import redis.clients.jedis.BinaryClient.LIST_POSITION;
import redis.clients.util.SafeEncoder; import redis.clients.util.SafeEncoder;
import redis.clients.util.Slowlog; import redis.clients.util.Slowlog;
import java.net.URI;
import java.util.*;
public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommands, AdvancedJedisCommands, ScriptingCommands { public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommands, AdvancedJedisCommands, ScriptingCommands {
public Jedis(final String host) { public Jedis(final String host) {
super(host); super(host);
@@ -3076,4 +3083,74 @@ public class Jedis extends BinaryJedis implements JedisCommands, MultiKeyCommand
String relpy = client.getBulkReply(); String relpy = client.getBulkReply();
return (relpy != null ? new Double(relpy) : null); return (relpy != null ? new Double(relpy) : null);
} }
public ScanResult<String> scan(int cursor) {
return scan(cursor, new ScanParams());
}
public ScanResult<String> scan(int cursor, final ScanParams params) {
checkIsInMulti();
client.scan(cursor, params);
List<Object> result = client.getObjectMultiBulkReply();
int newcursor = Integer.parseInt(new String((byte[])result.get(0)));
List<String> results = new ArrayList<String>();
List<byte[]> rawResults = (List<byte[]>)result.get(1);
for (byte[] bs : rawResults) {
results.add(SafeEncoder.encode(bs));
}
return new ScanResult<String>(newcursor, results);
}
public ScanResult<Map.Entry<String, String>> hscan(final String key, int cursor) {
return hscan(key, cursor, new ScanParams());
}
public ScanResult<Map.Entry<String, String>> hscan(final String key, int cursor, final ScanParams params) {
checkIsInMulti();
client.hscan(key, cursor, params);
List<Object> result = client.getObjectMultiBulkReply();
int newcursor = Integer.parseInt(new String((byte[])result.get(0)));
List<Map.Entry<String, String>> results = new ArrayList<Map.Entry<String, String>>();
List<byte[]> rawResults = (List<byte[]>)result.get(1);
Iterator<byte[]> iterator = rawResults.iterator();
while(iterator.hasNext()) {
results.add(new AbstractMap.SimpleEntry<String, String>(SafeEncoder.encode(iterator.next()), SafeEncoder.encode(iterator.next())));
}
return new ScanResult<Map.Entry<String, String>>(newcursor, results);
}
public ScanResult<String> sscan(final String key, int cursor) {
return sscan(key, cursor, new ScanParams());
}
public ScanResult<String> sscan(final String key, int cursor, final ScanParams params) {
checkIsInMulti();
client.sscan(key, cursor, params);
List<Object> result = client.getObjectMultiBulkReply();
int newcursor = Integer.parseInt(new String((byte[])result.get(0)));
List<String> results = new ArrayList<String>();
List<byte[]> rawResults = (List<byte[]>)result.get(1);
for (byte[] bs : rawResults) {
results.add(SafeEncoder.encode(bs));
}
return new ScanResult<String>(newcursor, results);
}
public ScanResult<Tuple> zscan(final String key, int cursor) {
return zscan(key, cursor, new ScanParams());
}
public ScanResult<Tuple> zscan(final String key, int cursor, final ScanParams params) {
checkIsInMulti();
client.zscan(key, cursor, params);
List<Object> result = client.getObjectMultiBulkReply();
int newcursor = Integer.parseInt(new String((byte[])result.get(0)));
List<Tuple> results = new ArrayList<Tuple>();
List<byte[]> rawResults = (List<byte[]>)result.get(1);
Iterator<byte[]> iterator = rawResults.iterator();
while(iterator.hasNext()) {
results.add(new Tuple(SafeEncoder.encode(iterator.next()), Double.valueOf(SafeEncoder.encode(iterator.next()))));
}
return new ScanResult<Tuple>(newcursor, results);
}
} }

6
src/main/java/redis/clients/jedis/JedisCommands.java
View File

@@ -211,4 +211,10 @@ public interface
Long bitcount(final String key); Long bitcount(final String key);
Long bitcount(final String key, long start, long end); Long bitcount(final String key, long start, long end);
ScanResult<Map.Entry<String, String>> hscan(final String key, int cursor);
ScanResult<String> sscan(final String key, int cursor);
ScanResult<Tuple> zscan(final String key, int cursor);
} }

3
src/main/java/redis/clients/jedis/MultiKeyCommands.java
View File

@@ -2,6 +2,7 @@ package redis.clients.jedis;
import java.util.List; import java.util.List;
import java.util.Map;
import java.util.Set; import java.util.Set;
public interface MultiKeyCommands { public interface MultiKeyCommands {
@@ -70,4 +71,6 @@ public interface MultiKeyCommands {
String randomKey(); String randomKey();
Long bitop(BitOP op, final String destKey, String... srcKeys); Long bitop(BitOP op, final String destKey, String... srcKeys);
ScanResult<String> scan(int cursor);
} }

4
src/main/java/redis/clients/jedis/Protocol.java
View File

@@ -158,7 +158,7 @@ public final class Protocol {
public static enum Command { public static enum Command {
PING, SET, GET, QUIT, EXISTS, DEL, TYPE, FLUSHDB, KEYS, RANDOMKEY, RENAME, RENAMENX, RENAMEX, DBSIZE, EXPIRE, EXPIREAT, TTL, SELECT, MOVE, FLUSHALL, GETSET, MGET, SETNX, SETEX, MSET, MSETNX, DECRBY, DECR, INCRBY, INCR, APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HEXISTS, HDEL, HLEN, HKEYS, HVALS, HGETALL, RPUSH, LPUSH, LLEN, LRANGE, LTRIM, LINDEX, LSET, LREM, LPOP, RPOP, RPOPLPUSH, SADD, SMEMBERS, SREM, SPOP, SMOVE, SCARD, SISMEMBER, SINTER, SINTERSTORE, SUNION, SUNIONSTORE, SDIFF, SDIFFSTORE, SRANDMEMBER, ZADD, ZRANGE, ZREM, ZINCRBY, ZRANK, ZREVRANK, ZREVRANGE, ZCARD, ZSCORE, MULTI, DISCARD, EXEC, WATCH, UNWATCH, SORT, BLPOP, BRPOP, AUTH, SUBSCRIBE, PUBLISH, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, ZCOUNT, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZREMRANGEBYRANK, ZREMRANGEBYSCORE, ZUNIONSTORE, ZINTERSTORE, SAVE, BGSAVE, BGREWRITEAOF, LASTSAVE, SHUTDOWN, INFO, MONITOR, SLAVEOF, CONFIG, STRLEN, SYNC, LPUSHX, PERSIST, RPUSHX, ECHO, LINSERT, DEBUG, BRPOPLPUSH, SETBIT, GETBIT, SETRANGE, GETRANGE, EVAL, EVALSHA, SCRIPT, SLOWLOG, OBJECT, BITCOUNT, BITOP, SENTINEL, PING, SET, GET, QUIT, EXISTS, DEL, TYPE, FLUSHDB, KEYS, RANDOMKEY, RENAME, RENAMENX, RENAMEX, DBSIZE, EXPIRE, EXPIREAT, TTL, SELECT, MOVE, FLUSHALL, GETSET, MGET, SETNX, SETEX, MSET, MSETNX, DECRBY, DECR, INCRBY, INCR, APPEND, SUBSTR, HSET, HGET, HSETNX, HMSET, HMGET, HINCRBY, HEXISTS, HDEL, HLEN, HKEYS, HVALS, HGETALL, RPUSH, LPUSH, LLEN, LRANGE, LTRIM, LINDEX, LSET, LREM, LPOP, RPOP, RPOPLPUSH, SADD, SMEMBERS, SREM, SPOP, SMOVE, SCARD, SISMEMBER, SINTER, SINTERSTORE, SUNION, SUNIONSTORE, SDIFF, SDIFFSTORE, SRANDMEMBER, ZADD, ZRANGE, ZREM, ZINCRBY, ZRANK, ZREVRANK, ZREVRANGE, ZCARD, ZSCORE, MULTI, DISCARD, EXEC, WATCH, UNWATCH, SORT, BLPOP, BRPOP, AUTH, SUBSCRIBE, PUBLISH, UNSUBSCRIBE, PSUBSCRIBE, PUNSUBSCRIBE, ZCOUNT, ZRANGEBYSCORE, ZREVRANGEBYSCORE, ZREMRANGEBYRANK, ZREMRANGEBYSCORE, ZUNIONSTORE, ZINTERSTORE, SAVE, BGSAVE, BGREWRITEAOF, LASTSAVE, SHUTDOWN, INFO, MONITOR, SLAVEOF, CONFIG, STRLEN, SYNC, LPUSHX, PERSIST, RPUSHX, ECHO, LINSERT, DEBUG, BRPOPLPUSH, SETBIT, GETBIT, SETRANGE, GETRANGE, EVAL, EVALSHA, SCRIPT, SLOWLOG, OBJECT, BITCOUNT, BITOP, SENTINEL,
DUMP, RESTORE, PEXPIRE, PEXPIREAT, PTTL, INCRBYFLOAT, PSETEX, CLIENT, TIME, MIGRATE, HINCRBYFLOAT; DUMP, RESTORE, PEXPIRE, PEXPIREAT, PTTL, INCRBYFLOAT, PSETEX, CLIENT, TIME, MIGRATE, HINCRBYFLOAT, SCAN, HSCAN, SSCAN, ZSCAN;
public final byte[] raw; public final byte[] raw;
@@ -169,7 +169,7 @@ public final class Protocol {
public static enum Keyword { public static enum Keyword {
AGGREGATE, ALPHA, ASC, BY, DESC, GET, LIMIT, MESSAGE, NO, NOSORT, PMESSAGE, PSUBSCRIBE, PUNSUBSCRIBE, OK, ONE, QUEUED, SET, STORE, SUBSCRIBE, UNSUBSCRIBE, WEIGHTS, WITHSCORES, RESETSTAT, RESET, FLUSH, EXISTS, LOAD, KILL, LEN, REFCOUNT, ENCODING, IDLETIME, AND, OR, XOR, NOT, AGGREGATE, ALPHA, ASC, BY, DESC, GET, LIMIT, MESSAGE, NO, NOSORT, PMESSAGE, PSUBSCRIBE, PUNSUBSCRIBE, OK, ONE, QUEUED, SET, STORE, SUBSCRIBE, UNSUBSCRIBE, WEIGHTS, WITHSCORES, RESETSTAT, RESET, FLUSH, EXISTS, LOAD, KILL, LEN, REFCOUNT, ENCODING, IDLETIME, AND, OR, XOR, NOT,
GETNAME, SETNAME,LIST; GETNAME, SETNAME,LIST, MATCH, COUNT;
public final byte[] raw; public final byte[] raw;
Keyword() { Keyword() {

29
src/main/java/redis/clients/jedis/ScanParams.java Normal file
View File

@@ -0,0 +1,29 @@
package redis.clients.jedis;
import static redis.clients.jedis.Protocol.Keyword.COUNT;
import static redis.clients.jedis.Protocol.Keyword.MATCH;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import redis.clients.util.SafeEncoder;
public class ScanParams {
private List<byte[]> params = new ArrayList<byte[]>();
public void match(final String pattern) {
params.add(MATCH.raw);
params.add(SafeEncoder.encode(pattern));
}
public void count(final int count) {
params.add(COUNT.raw);
params.add(Protocol.toByteArray(count));
}
public Collection<byte[]> getParams() {
return Collections.unmodifiableCollection(params);
}
}

21
src/main/java/redis/clients/jedis/ScanResult.java Normal file
View File

@@ -0,0 +1,21 @@
package redis.clients.jedis;
import java.util.List;
public class ScanResult<T> {
private int cursor;
private List<T> results;
public ScanResult(int cursor, List<T> results) {
this.cursor = cursor;
this.results = results;
}
public int getCursor() {
return cursor;
}
public List<T> getResult() {
return results;
}
}

14
src/main/java/redis/clients/jedis/ShardedJedis.java
View File

@@ -5,6 +5,7 @@ import redis.clients.util.Hashing;
import java.util.List; import java.util.List;
import java.util.Map; import java.util.Map;
import java.util.Map.Entry;
import java.util.Set; import java.util.Set;
import java.util.regex.Pattern; import java.util.regex.Pattern;
@@ -522,5 +523,18 @@ public class ShardedJedis extends BinaryShardedJedis implements JedisCommands {
return j.bitcount(key, start, end); return j.bitcount(key, start, end);
} }
public ScanResult<Entry<String, String>> hscan(String key, int cursor) {
Jedis j = getShard(key);
return j.hscan(key, cursor);
}
public ScanResult<String> sscan(String key, int cursor) {
Jedis j = getShard(key);
return j.sscan(key, cursor);
}
public ScanResult<Tuple> zscan(String key, int cursor) {
Jedis j = getShard(key);
return j.zscan(key, cursor);
}
} }

644
src/test/java/redis/clients/jedis/tests/commands/AllKindOfValuesCommandsTest.java
View File

@@ -6,6 +6,8 @@ import java.util.Set;
import org.junit.Test; import org.junit.Test;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.exceptions.JedisDataException; import redis.clients.jedis.exceptions.JedisDataException;
import redis.clients.util.SafeEncoder; import redis.clients.util.SafeEncoder;
@@ -25,482 +27,520 @@ public class AllKindOfValuesCommandsTest extends JedisCommandTestBase {
@Test @Test
public void ping() { public void ping() {
String status = jedis.ping(); String status = jedis.ping();
assertEquals("PONG", status); assertEquals("PONG", status);
} }
@Test @Test
public void exists() { public void exists() {
String status = jedis.set("foo", "bar"); String status = jedis.set("foo", "bar");
assertEquals("OK", status); assertEquals("OK", status);
status = jedis.set(bfoo, bbar); status = jedis.set(bfoo, bbar);
assertEquals("OK", status); assertEquals("OK", status);
boolean reply = jedis.exists("foo"); boolean reply = jedis.exists("foo");
assertTrue(reply); assertTrue(reply);
reply = jedis.exists(bfoo); reply = jedis.exists(bfoo);
assertTrue(reply); assertTrue(reply);
long lreply = jedis.del("foo"); long lreply = jedis.del("foo");
assertEquals(1, lreply); assertEquals(1, lreply);
lreply = jedis.del(bfoo); lreply = jedis.del(bfoo);
assertEquals(1, lreply); assertEquals(1, lreply);
reply = jedis.exists("foo"); reply = jedis.exists("foo");
assertFalse(reply); assertFalse(reply);
reply = jedis.exists(bfoo); reply = jedis.exists(bfoo);
assertFalse(reply); assertFalse(reply);
} }
@Test @Test
public void del() { public void del() {
jedis.set("foo1", "bar1"); jedis.set("foo1", "bar1");
jedis.set("foo2", "bar2"); jedis.set("foo2", "bar2");
jedis.set("foo3", "bar3"); jedis.set("foo3", "bar3");
long reply = jedis.del("foo1", "foo2", "foo3"); long reply = jedis.del("foo1", "foo2", "foo3");
assertEquals(3, reply); assertEquals(3, reply);
Boolean breply = jedis.exists("foo1"); Boolean breply = jedis.exists("foo1");
assertFalse(breply); assertFalse(breply);
breply = jedis.exists("foo2"); breply = jedis.exists("foo2");
assertFalse(breply); assertFalse(breply);
breply = jedis.exists("foo3"); breply = jedis.exists("foo3");
assertFalse(breply); assertFalse(breply);
jedis.set("foo1", "bar1"); jedis.set("foo1", "bar1");
reply = jedis.del("foo1", "foo2"); reply = jedis.del("foo1", "foo2");
assertEquals(1, reply); assertEquals(1, reply);
reply = jedis.del("foo1", "foo2"); reply = jedis.del("foo1", "foo2");
assertEquals(0, reply); assertEquals(0, reply);
// Binary ... // Binary ...
jedis.set(bfoo1, bbar1); jedis.set(bfoo1, bbar1);
jedis.set(bfoo2, bbar2); jedis.set(bfoo2, bbar2);
jedis.set(bfoo3, bbar3); jedis.set(bfoo3, bbar3);
reply = jedis.del(bfoo1, bfoo2, bfoo3); reply = jedis.del(bfoo1, bfoo2, bfoo3);
assertEquals(3, reply); assertEquals(3, reply);
breply = jedis.exists(bfoo1); breply = jedis.exists(bfoo1);
assertFalse(breply); assertFalse(breply);
breply = jedis.exists(bfoo2); breply = jedis.exists(bfoo2);
assertFalse(breply); assertFalse(breply);
breply = jedis.exists(bfoo3); breply = jedis.exists(bfoo3);
assertFalse(breply); assertFalse(breply);
jedis.set(bfoo1, bbar1); jedis.set(bfoo1, bbar1);
reply = jedis.del(bfoo1, bfoo2); reply = jedis.del(bfoo1, bfoo2);
assertEquals(1, reply); assertEquals(1, reply);
reply = jedis.del(bfoo1, bfoo2); reply = jedis.del(bfoo1, bfoo2);
assertEquals(0, reply); assertEquals(0, reply);
} }
@Test @Test
public void type() { public void type() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
String status = jedis.type("foo"); String status = jedis.type("foo");
assertEquals("string", status); assertEquals("string", status);
// Binary // Binary
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
status = jedis.type(bfoo); status = jedis.type(bfoo);
assertEquals("string", status); assertEquals("string", status);
} }
@Test @Test
public void keys() { public void keys() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
jedis.set("foobar", "bar"); jedis.set("foobar", "bar");
Set<String> keys = jedis.keys("foo*"); Set<String> keys = jedis.keys("foo*");
Set<String> expected = new HashSet<String>(); Set<String> expected = new HashSet<String>();
expected.add("foo"); expected.add("foo");
expected.add("foobar"); expected.add("foobar");
assertEquals(expected, keys); assertEquals(expected, keys);
expected = new HashSet<String>(); expected = new HashSet<String>();
keys = jedis.keys("bar*"); keys = jedis.keys("bar*");
assertEquals(expected, keys); assertEquals(expected, keys);
// Binary // Binary
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
jedis.set(bfoobar, bbar); jedis.set(bfoobar, bbar);
Set<byte[]> bkeys = jedis.keys(bfoostar); Set<byte[]> bkeys = jedis.keys(bfoostar);
assertEquals(2, bkeys.size()); assertEquals(2, bkeys.size());
assertTrue(setContains(bkeys, bfoo)); assertTrue(setContains(bkeys, bfoo));
assertTrue(setContains(bkeys, bfoobar)); assertTrue(setContains(bkeys, bfoobar));
bkeys = jedis.keys(bbarstar); bkeys = jedis.keys(bbarstar);
assertEquals(0, bkeys.size()); assertEquals(0, bkeys.size());
} }
@Test @Test
public void randomKey() { public void randomKey() {
assertEquals(null, jedis.randomKey()); assertEquals(null, jedis.randomKey());
jedis.set("foo", "bar"); jedis.set("foo", "bar");
assertEquals("foo", jedis.randomKey()); assertEquals("foo", jedis.randomKey());
jedis.set("bar", "foo"); jedis.set("bar", "foo");
String randomkey = jedis.randomKey(); String randomkey = jedis.randomKey();
assertTrue(randomkey.equals("foo") || randomkey.equals("bar")); assertTrue(randomkey.equals("foo") || randomkey.equals("bar"));
// Binary // Binary
jedis.del("foo"); jedis.del("foo");
jedis.del("bar"); jedis.del("bar");
assertEquals(null, jedis.randomKey()); assertEquals(null, jedis.randomKey());
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
assertArrayEquals(bfoo, jedis.randomBinaryKey()); assertArrayEquals(bfoo, jedis.randomBinaryKey());
jedis.set(bbar, bfoo); jedis.set(bbar, bfoo);
byte[] randomBkey = jedis.randomBinaryKey(); byte[] randomBkey = jedis.randomBinaryKey();
assertTrue(Arrays.equals(randomBkey, bfoo) assertTrue(Arrays.equals(randomBkey, bfoo)
|| Arrays.equals(randomBkey, bbar)); || Arrays.equals(randomBkey, bbar));
} }
@Test @Test
public void rename() { public void rename() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
String status = jedis.rename("foo", "bar"); String status = jedis.rename("foo", "bar");
assertEquals("OK", status); assertEquals("OK", status);
String value = jedis.get("foo"); String value = jedis.get("foo");
assertEquals(null, value); assertEquals(null, value);
value = jedis.get("bar"); value = jedis.get("bar");
assertEquals("bar", value); assertEquals("bar", value);
// Binary // Binary
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
String bstatus = jedis.rename(bfoo, bbar); String bstatus = jedis.rename(bfoo, bbar);
assertEquals("OK", bstatus); assertEquals("OK", bstatus);
byte[] bvalue = jedis.get(bfoo); byte[] bvalue = jedis.get(bfoo);
assertEquals(null, bvalue); assertEquals(null, bvalue);
bvalue = jedis.get(bbar); bvalue = jedis.get(bbar);
assertArrayEquals(bbar, bvalue); assertArrayEquals(bbar, bvalue);
} }
@Test @Test
public void renameOldAndNewAreTheSame() { public void renameOldAndNewAreTheSame() {
try { try {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
jedis.rename("foo", "foo"); jedis.rename("foo", "foo");
fail("JedisDataException expected"); fail("JedisDataException expected");
} catch (final JedisDataException e) { } catch (final JedisDataException e) {
} }
// Binary // Binary
try { try {
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
jedis.rename(bfoo, bfoo); jedis.rename(bfoo, bfoo);
fail("JedisDataException expected"); fail("JedisDataException expected");
} catch (final JedisDataException e) { } catch (final JedisDataException e) {
} }
} }
@Test @Test
public void renamenx() { public void renamenx() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
long status = jedis.renamenx("foo", "bar"); long status = jedis.renamenx("foo", "bar");
assertEquals(1, status); assertEquals(1, status);
jedis.set("foo", "bar"); jedis.set("foo", "bar");
status = jedis.renamenx("foo", "bar"); status = jedis.renamenx("foo", "bar");
assertEquals(0, status); assertEquals(0, status);
// Binary // Binary
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
long bstatus = jedis.renamenx(bfoo, bbar); long bstatus = jedis.renamenx(bfoo, bbar);
assertEquals(1, bstatus); assertEquals(1, bstatus);
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
bstatus = jedis.renamenx(bfoo, bbar); bstatus = jedis.renamenx(bfoo, bbar);
assertEquals(0, bstatus); assertEquals(0, bstatus);
} }
@Test @Test
public void dbSize() { public void dbSize() {
long size = jedis.dbSize(); long size = jedis.dbSize();
assertEquals(0, size); assertEquals(0, size);
jedis.set("foo", "bar"); jedis.set("foo", "bar");
size = jedis.dbSize(); size = jedis.dbSize();
assertEquals(1, size); assertEquals(1, size);
// Binary // Binary
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
size = jedis.dbSize(); size = jedis.dbSize();
assertEquals(2, size); assertEquals(2, size);
} }
@Test @Test
public void expire() { public void expire() {
long status = jedis.expire("foo", 20); long status = jedis.expire("foo", 20);
assertEquals(0, status); assertEquals(0, status);
jedis.set("foo", "bar"); jedis.set("foo", "bar");
status = jedis.expire("foo", 20); status = jedis.expire("foo", 20);
assertEquals(1, status); assertEquals(1, status);
// Binary // Binary
long bstatus = jedis.expire(bfoo, 20); long bstatus = jedis.expire(bfoo, 20);
assertEquals(0, bstatus); assertEquals(0, bstatus);
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
bstatus = jedis.expire(bfoo, 20); bstatus = jedis.expire(bfoo, 20);
assertEquals(1, bstatus); assertEquals(1, bstatus);
} }
@Test @Test
public void expireAt() { public void expireAt() {
long unixTime = (System.currentTimeMillis() / 1000L) + 20; long unixTime = (System.currentTimeMillis() / 1000L) + 20;
long status = jedis.expireAt("foo", unixTime); long status = jedis.expireAt("foo", unixTime);
assertEquals(0, status); assertEquals(0, status);
jedis.set("foo", "bar"); jedis.set("foo", "bar");
unixTime = (System.currentTimeMillis() / 1000L) + 20; unixTime = (System.currentTimeMillis() / 1000L) + 20;
status = jedis.expireAt("foo", unixTime); status = jedis.expireAt("foo", unixTime);
assertEquals(1, status); assertEquals(1, status);
// Binary // Binary
long bstatus = jedis.expireAt(bfoo, unixTime); long bstatus = jedis.expireAt(bfoo, unixTime);
assertEquals(0, bstatus); assertEquals(0, bstatus);
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
unixTime = (System.currentTimeMillis() / 1000L) + 20; unixTime = (System.currentTimeMillis() / 1000L) + 20;
bstatus = jedis.expireAt(bfoo, unixTime); bstatus = jedis.expireAt(bfoo, unixTime);
assertEquals(1, bstatus); assertEquals(1, bstatus);
} }
@Test @Test
public void ttl() { public void ttl() {
long ttl = jedis.ttl("foo"); long ttl = jedis.ttl("foo");
assertEquals(-2, ttl); assertEquals(-2, ttl);
jedis.set("foo", "bar"); jedis.set("foo", "bar");
ttl = jedis.ttl("foo"); ttl = jedis.ttl("foo");
assertEquals(-1, ttl); assertEquals(-1, ttl);
jedis.expire("foo", 20); jedis.expire("foo", 20);
ttl = jedis.ttl("foo"); ttl = jedis.ttl("foo");
assertTrue(ttl >= 0 && ttl <= 20); assertTrue(ttl >= 0 && ttl <= 20);
// Binary // Binary
long bttl = jedis.ttl(bfoo); long bttl = jedis.ttl(bfoo);
assertEquals(-2, bttl); assertEquals(-2, bttl);
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
bttl = jedis.ttl(bfoo); bttl = jedis.ttl(bfoo);
assertEquals(-1, bttl); assertEquals(-1, bttl);
jedis.expire(bfoo, 20); jedis.expire(bfoo, 20);
bttl = jedis.ttl(bfoo); bttl = jedis.ttl(bfoo);
assertTrue(bttl >= 0 && bttl <= 20); assertTrue(bttl >= 0 && bttl <= 20);
} }
@Test @Test
public void select() { public void select() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
String status = jedis.select(1); String status = jedis.select(1);
assertEquals("OK", status); assertEquals("OK", status);
assertEquals(null, jedis.get("foo")); assertEquals(null, jedis.get("foo"));
status = jedis.select(0); status = jedis.select(0);
assertEquals("OK", status); assertEquals("OK", status);
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
// Binary // Binary
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
String bstatus = jedis.select(1); String bstatus = jedis.select(1);
assertEquals("OK", bstatus); assertEquals("OK", bstatus);
assertEquals(null, jedis.get(bfoo)); assertEquals(null, jedis.get(bfoo));
bstatus = jedis.select(0); bstatus = jedis.select(0);
assertEquals("OK", bstatus); assertEquals("OK", bstatus);
assertArrayEquals(bbar, jedis.get(bfoo)); assertArrayEquals(bbar, jedis.get(bfoo));
} }
@Test @Test
public void getDB() { public void getDB() {
assertEquals(0, jedis.getDB().longValue()); assertEquals(0, jedis.getDB().longValue());
jedis.select(1); jedis.select(1);
assertEquals(1, jedis.getDB().longValue()); assertEquals(1, jedis.getDB().longValue());
} }
@Test @Test
public void move() { public void move() {
long status = jedis.move("foo", 1); long status = jedis.move("foo", 1);
assertEquals(0, status); assertEquals(0, status);
jedis.set("foo", "bar"); jedis.set("foo", "bar");
status = jedis.move("foo", 1); status = jedis.move("foo", 1);
assertEquals(1, status); assertEquals(1, status);
assertEquals(null, jedis.get("foo")); assertEquals(null, jedis.get("foo"));
jedis.select(1); jedis.select(1);
assertEquals("bar", jedis.get("foo")); assertEquals("bar", jedis.get("foo"));
// Binary // Binary
jedis.select(0); jedis.select(0);
long bstatus = jedis.move(bfoo, 1); long bstatus = jedis.move(bfoo, 1);
assertEquals(0, bstatus); assertEquals(0, bstatus);
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
bstatus = jedis.move(bfoo, 1); bstatus = jedis.move(bfoo, 1);
assertEquals(1, bstatus); assertEquals(1, bstatus);
assertEquals(null, jedis.get(bfoo)); assertEquals(null, jedis.get(bfoo));
jedis.select(1); jedis.select(1);
assertArrayEquals(bbar, jedis.get(bfoo)); assertArrayEquals(bbar, jedis.get(bfoo));
} }
@Test @Test
public void flushDB() { public void flushDB() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
assertEquals(1, jedis.dbSize().intValue()); assertEquals(1, jedis.dbSize().intValue());
jedis.set("bar", "foo"); jedis.set("bar", "foo");
jedis.move("bar", 1); jedis.move("bar", 1);
String status = jedis.flushDB(); String status = jedis.flushDB();
assertEquals("OK", status); assertEquals("OK", status);
assertEquals(0, jedis.dbSize().intValue()); assertEquals(0, jedis.dbSize().intValue());
jedis.select(1); jedis.select(1);
assertEquals(1, jedis.dbSize().intValue()); assertEquals(1, jedis.dbSize().intValue());
jedis.del("bar"); jedis.del("bar");
// Binary // Binary
jedis.select(0); jedis.select(0);
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
assertEquals(1, jedis.dbSize().intValue()); assertEquals(1, jedis.dbSize().intValue());
jedis.set(bbar, bfoo); jedis.set(bbar, bfoo);
jedis.move(bbar, 1); jedis.move(bbar, 1);
String bstatus = jedis.flushDB(); String bstatus = jedis.flushDB();
assertEquals("OK", bstatus); assertEquals("OK", bstatus);
assertEquals(0, jedis.dbSize().intValue()); assertEquals(0, jedis.dbSize().intValue());
jedis.select(1); jedis.select(1);
assertEquals(1, jedis.dbSize().intValue()); assertEquals(1, jedis.dbSize().intValue());
} }
@Test @Test
public void flushAll() { public void flushAll() {
jedis.set("foo", "bar"); jedis.set("foo", "bar");
assertEquals(1, jedis.dbSize().intValue()); assertEquals(1, jedis.dbSize().intValue());
jedis.set("bar", "foo"); jedis.set("bar", "foo");
jedis.move("bar", 1); jedis.move("bar", 1);
String status = jedis.flushAll(); String status = jedis.flushAll();
assertEquals("OK", status); assertEquals("OK", status);
assertEquals(0, jedis.dbSize().intValue()); assertEquals(0, jedis.dbSize().intValue());
jedis.select(1); jedis.select(1);
assertEquals(0, jedis.dbSize().intValue()); assertEquals(0, jedis.dbSize().intValue());
// Binary // Binary
jedis.select(0); jedis.select(0);
jedis.set(bfoo, bbar); jedis.set(bfoo, bbar);
assertEquals(1, jedis.dbSize().intValue()); assertEquals(1, jedis.dbSize().intValue());
jedis.set(bbar, bfoo); jedis.set(bbar, bfoo);
jedis.move(bbar, 1); jedis.move(bbar, 1);
String bstatus = jedis.flushAll(); String bstatus = jedis.flushAll();
assertEquals("OK", bstatus); assertEquals("OK", bstatus);
assertEquals(0, jedis.dbSize().intValue()); assertEquals(0, jedis.dbSize().intValue());
jedis.select(1); jedis.select(1);
assertEquals(0, jedis.dbSize().intValue()); assertEquals(0, jedis.dbSize().intValue());
} }
@Test @Test
public void persist() { public void persist() {
jedis.setex("foo", 60 * 60, "bar"); jedis.setex("foo", 60 * 60, "bar");
assertTrue(jedis.ttl("foo") > 0); assertTrue(jedis.ttl("foo") > 0);
long status = jedis.persist("foo"); long status = jedis.persist("foo");
assertEquals(1, status); assertEquals(1, status);
assertEquals(-1, jedis.ttl("foo").intValue()); assertEquals(-1, jedis.ttl("foo").intValue());
// Binary // Binary
jedis.setex(bfoo, 60 * 60, bbar); jedis.setex(bfoo, 60 * 60, bbar);
assertTrue(jedis.ttl(bfoo) > 0); assertTrue(jedis.ttl(bfoo) > 0);
long bstatus = jedis.persist(bfoo); long bstatus = jedis.persist(bfoo);
assertEquals(1, bstatus); assertEquals(1, bstatus);
assertEquals(-1, jedis.ttl(bfoo).intValue()); assertEquals(-1, jedis.ttl(bfoo).intValue());
} }
@Test @Test
public void echo() { public void echo() {
String result = jedis.echo("hello world"); String result = jedis.echo("hello world");
assertEquals("hello world", result); assertEquals("hello world", result);
// Binary // Binary
byte[] bresult = jedis.echo(SafeEncoder.encode("hello world")); byte[] bresult = jedis.echo(SafeEncoder.encode("hello world"));
assertArrayEquals(SafeEncoder.encode("hello world"), bresult); assertArrayEquals(SafeEncoder.encode("hello world"), bresult);
} }
@Test @Test
public void dumpAndRestore() { public void dumpAndRestore() {
jedis.set("foo1", "bar1"); jedis.set("foo1", "bar1");
byte[] sv = jedis.dump("foo1"); byte[] sv = jedis.dump("foo1");
jedis.restore("foo2", 0, sv); jedis.restore("foo2", 0, sv);
assertTrue(jedis.exists("foo2")); assertTrue(jedis.exists("foo2"));
} }
@Test @Test
public void pexpire() { public void pexpire() {
long status = jedis.pexpire("foo", 10000); long status = jedis.pexpire("foo", 10000);
assertEquals(0, status); assertEquals(0, status);
jedis.set("foo", "bar"); jedis.set("foo", "bar");
status = jedis.pexpire("foo", 10000); status = jedis.pexpire("foo", 10000);
assertEquals(1, status); assertEquals(1, status);
} }
@Test @Test
public void pexpireAt() { public void pexpireAt() {
long unixTime = (System.currentTimeMillis()) + 10000; long unixTime = (System.currentTimeMillis()) + 10000;
long status = jedis.pexpireAt("foo", unixTime); long status = jedis.pexpireAt("foo", unixTime);
assertEquals(0, status); assertEquals(0, status);
jedis.set("foo", "bar"); jedis.set("foo", "bar");
unixTime = (System.currentTimeMillis()) + 10000; unixTime = (System.currentTimeMillis()) + 10000;
status = jedis.pexpireAt("foo", unixTime); status = jedis.pexpireAt("foo", unixTime);
assertEquals(1, status); assertEquals(1, status);
} }
@Test @Test
public void pttl() { public void pttl() {
long pttl = jedis.pttl("foo"); long pttl = jedis.pttl("foo");
assertEquals(-2, pttl); assertEquals(-2, pttl);
jedis.set("foo", "bar"); jedis.set("foo", "bar");
pttl = jedis.pttl("foo"); pttl = jedis.pttl("foo");
assertEquals(-1, pttl); assertEquals(-1, pttl);
jedis.pexpire("foo", 20000); jedis.pexpire("foo", 20000);
pttl = jedis.pttl("foo"); pttl = jedis.pttl("foo");
assertTrue(pttl >= 0 && pttl <= 20000); assertTrue(pttl >= 0 && pttl <= 20000);
} }
@Test
public void scan() {
jedis.set("b", "b");
jedis.set("a", "a");
ScanResult<String> result = jedis.scan(0);
assertEquals(0, result.getCursor());
assertFalse(result.getResult().isEmpty());
}
@Test
public void scanMatch() {
ScanParams params = new ScanParams();
params.match("a*");
jedis.set("b", "b");
jedis.set("a", "a");
jedis.set("aa", "aa");
ScanResult<String> result = jedis.scan(0, params);
assertEquals(0, result.getCursor());
assertFalse(result.getResult().isEmpty());
}
@Test
public void scanCount() {
ScanParams params = new ScanParams();
params.count(2);
for (int i = 0; i < 10; i++) {
jedis.set("a" + i, "a" + i);
}
ScanResult<String> result = jedis.scan(0, params);
assertFalse(result.getResult().isEmpty());
}
} }

410
src/test/java/redis/clients/jedis/tests/commands/HashesCommandsTest.java
View File

@@ -10,6 +10,9 @@ import java.util.Set;
import org.junit.Test; import org.junit.Test;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
public class HashesCommandsTest extends JedisCommandTestBase { public class HashesCommandsTest extends JedisCommandTestBase {
final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 }; final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 }; final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 };
@@ -17,273 +20,312 @@ public class HashesCommandsTest extends JedisCommandTestBase {
@Test @Test
public void hset() { public void hset() {
long status = jedis.hset("foo", "bar", "car"); long status = jedis.hset("foo", "bar", "car");
assertEquals(1, status); assertEquals(1, status);
status = jedis.hset("foo", "bar", "foo"); status = jedis.hset("foo", "bar", "foo");
assertEquals(0, status); assertEquals(0, status);
// Binary // Binary
long bstatus = jedis.hset(bfoo, bbar, bcar); long bstatus = jedis.hset(bfoo, bbar, bcar);
assertEquals(1, bstatus); assertEquals(1, bstatus);
bstatus = jedis.hset(bfoo, bbar, bfoo); bstatus = jedis.hset(bfoo, bbar, bfoo);
assertEquals(0, bstatus); assertEquals(0, bstatus);
} }
@Test @Test
public void hget() { public void hget() {
jedis.hset("foo", "bar", "car"); jedis.hset("foo", "bar", "car");
assertEquals(null, jedis.hget("bar", "foo")); assertEquals(null, jedis.hget("bar", "foo"));
assertEquals(null, jedis.hget("foo", "car")); assertEquals(null, jedis.hget("foo", "car"));
assertEquals("car", jedis.hget("foo", "bar")); assertEquals("car", jedis.hget("foo", "bar"));
// Binary // Binary
jedis.hset(bfoo, bbar, bcar); jedis.hset(bfoo, bbar, bcar);
assertEquals(null, jedis.hget(bbar, bfoo)); assertEquals(null, jedis.hget(bbar, bfoo));
assertEquals(null, jedis.hget(bfoo, bcar)); assertEquals(null, jedis.hget(bfoo, bcar));
assertArrayEquals(bcar, jedis.hget(bfoo, bbar)); assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
} }
@Test @Test
public void hsetnx() { public void hsetnx() {
long status = jedis.hsetnx("foo", "bar", "car"); long status = jedis.hsetnx("foo", "bar", "car");
assertEquals(1, status); assertEquals(1, status);
assertEquals("car", jedis.hget("foo", "bar")); assertEquals("car", jedis.hget("foo", "bar"));
status = jedis.hsetnx("foo", "bar", "foo"); status = jedis.hsetnx("foo", "bar", "foo");
assertEquals(0, status); assertEquals(0, status);
assertEquals("car", jedis.hget("foo", "bar")); assertEquals("car", jedis.hget("foo", "bar"));
status = jedis.hsetnx("foo", "car", "bar"); status = jedis.hsetnx("foo", "car", "bar");
assertEquals(1, status); assertEquals(1, status);
assertEquals("bar", jedis.hget("foo", "car")); assertEquals("bar", jedis.hget("foo", "car"));
// Binary // Binary
long bstatus = jedis.hsetnx(bfoo, bbar, bcar); long bstatus = jedis.hsetnx(bfoo, bbar, bcar);
assertEquals(1, bstatus); assertEquals(1, bstatus);
assertArrayEquals(bcar, jedis.hget(bfoo, bbar)); assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
bstatus = jedis.hsetnx(bfoo, bbar, bfoo); bstatus = jedis.hsetnx(bfoo, bbar, bfoo);
assertEquals(0, bstatus); assertEquals(0, bstatus);
assertArrayEquals(bcar, jedis.hget(bfoo, bbar)); assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
bstatus = jedis.hsetnx(bfoo, bcar, bbar); bstatus = jedis.hsetnx(bfoo, bcar, bbar);
assertEquals(1, bstatus); assertEquals(1, bstatus);
assertArrayEquals(bbar, jedis.hget(bfoo, bcar)); assertArrayEquals(bbar, jedis.hget(bfoo, bcar));
} }
@Test @Test
public void hmset() { public void hmset() {
Map<String, String> hash = new HashMap<String, String>(); Map<String, String> hash = new HashMap<String, String>();
hash.put("bar", "car"); hash.put("bar", "car");
hash.put("car", "bar"); hash.put("car", "bar");
String status = jedis.hmset("foo", hash); String status = jedis.hmset("foo", hash);
assertEquals("OK", status); assertEquals("OK", status);
assertEquals("car", jedis.hget("foo", "bar")); assertEquals("car", jedis.hget("foo", "bar"));
assertEquals("bar", jedis.hget("foo", "car")); assertEquals("bar", jedis.hget("foo", "car"));
// Binary // Binary
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(); Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
bhash.put(bbar, bcar); bhash.put(bbar, bcar);
bhash.put(bcar, bbar); bhash.put(bcar, bbar);
String bstatus = jedis.hmset(bfoo, bhash); String bstatus = jedis.hmset(bfoo, bhash);
assertEquals("OK", bstatus); assertEquals("OK", bstatus);
assertArrayEquals(bcar, jedis.hget(bfoo, bbar)); assertArrayEquals(bcar, jedis.hget(bfoo, bbar));
assertArrayEquals(bbar, jedis.hget(bfoo, bcar)); assertArrayEquals(bbar, jedis.hget(bfoo, bcar));
} }
@Test @Test
public void hmget() { public void hmget() {
Map<String, String> hash = new HashMap<String, String>(); Map<String, String> hash = new HashMap<String, String>();
hash.put("bar", "car"); hash.put("bar", "car");
hash.put("car", "bar"); hash.put("car", "bar");
jedis.hmset("foo", hash); jedis.hmset("foo", hash);
List<String> values = jedis.hmget("foo", "bar", "car", "foo"); List<String> values = jedis.hmget("foo", "bar", "car", "foo");
List<String> expected = new ArrayList<String>(); List<String> expected = new ArrayList<String>();
expected.add("car"); expected.add("car");
expected.add("bar"); expected.add("bar");
expected.add(null); expected.add(null);
assertEquals(expected, values); assertEquals(expected, values);
// Binary // Binary
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(); Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
bhash.put(bbar, bcar); bhash.put(bbar, bcar);
bhash.put(bcar, bbar); bhash.put(bcar, bbar);
jedis.hmset(bfoo, bhash); jedis.hmset(bfoo, bhash);
List<byte[]> bvalues = jedis.hmget(bfoo, bbar, bcar, bfoo); List<byte[]> bvalues = jedis.hmget(bfoo, bbar, bcar, bfoo);
List<byte[]> bexpected = new ArrayList<byte[]>(); List<byte[]> bexpected = new ArrayList<byte[]>();
bexpected.add(bcar); bexpected.add(bcar);
bexpected.add(bbar); bexpected.add(bbar);
bexpected.add(null); bexpected.add(null);
assertEquals(bexpected, bvalues); assertEquals(bexpected, bvalues);
} }
@Test @Test
public void hincrBy() { public void hincrBy() {
long value = jedis.hincrBy("foo", "bar", 1); long value = jedis.hincrBy("foo", "bar", 1);
assertEquals(1, value); assertEquals(1, value);
value = jedis.hincrBy("foo", "bar", -1); value = jedis.hincrBy("foo", "bar", -1);
assertEquals(0, value); assertEquals(0, value);
value = jedis.hincrBy("foo", "bar", -10); value = jedis.hincrBy("foo", "bar", -10);
assertEquals(-10, value); assertEquals(-10, value);
// Binary // Binary
long bvalue = jedis.hincrBy(bfoo, bbar, 1); long bvalue = jedis.hincrBy(bfoo, bbar, 1);
assertEquals(1, bvalue); assertEquals(1, bvalue);
bvalue = jedis.hincrBy(bfoo, bbar, -1); bvalue = jedis.hincrBy(bfoo, bbar, -1);
assertEquals(0, bvalue); assertEquals(0, bvalue);
bvalue = jedis.hincrBy(bfoo, bbar, -10); bvalue = jedis.hincrBy(bfoo, bbar, -10);
assertEquals(-10, bvalue); assertEquals(-10, bvalue);
} }
@Test @Test
public void hexists() { public void hexists() {
Map<String, String> hash = new HashMap<String, String>(); Map<String, String> hash = new HashMap<String, String>();
hash.put("bar", "car"); hash.put("bar", "car");
hash.put("car", "bar"); hash.put("car", "bar");
jedis.hmset("foo", hash); jedis.hmset("foo", hash);
assertFalse(jedis.hexists("bar", "foo")); assertFalse(jedis.hexists("bar", "foo"));
assertFalse(jedis.hexists("foo", "foo")); assertFalse(jedis.hexists("foo", "foo"));
assertTrue(jedis.hexists("foo", "bar")); assertTrue(jedis.hexists("foo", "bar"));
// Binary // Binary
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(); Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
bhash.put(bbar, bcar); bhash.put(bbar, bcar);
bhash.put(bcar, bbar); bhash.put(bcar, bbar);
jedis.hmset(bfoo, bhash); jedis.hmset(bfoo, bhash);
assertFalse(jedis.hexists(bbar, bfoo)); assertFalse(jedis.hexists(bbar, bfoo));
assertFalse(jedis.hexists(bfoo, bfoo)); assertFalse(jedis.hexists(bfoo, bfoo));
assertTrue(jedis.hexists(bfoo, bbar)); assertTrue(jedis.hexists(bfoo, bbar));
} }
@Test @Test
public void hdel() { public void hdel() {
Map<String, String> hash = new HashMap<String, String>(); Map<String, String> hash = new HashMap<String, String>();
hash.put("bar", "car"); hash.put("bar", "car");
hash.put("car", "bar"); hash.put("car", "bar");
jedis.hmset("foo", hash); jedis.hmset("foo", hash);
assertEquals(0, jedis.hdel("bar", "foo").intValue()); assertEquals(0, jedis.hdel("bar", "foo").intValue());
assertEquals(0, jedis.hdel("foo", "foo").intValue()); assertEquals(0, jedis.hdel("foo", "foo").intValue());
assertEquals(1, jedis.hdel("foo", "bar").intValue()); assertEquals(1, jedis.hdel("foo", "bar").intValue());
assertEquals(null, jedis.hget("foo", "bar")); assertEquals(null, jedis.hget("foo", "bar"));
// Binary // Binary
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(); Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
bhash.put(bbar, bcar); bhash.put(bbar, bcar);
bhash.put(bcar, bbar); bhash.put(bcar, bbar);
jedis.hmset(bfoo, bhash); jedis.hmset(bfoo, bhash);
assertEquals(0, jedis.hdel(bbar, bfoo).intValue()); assertEquals(0, jedis.hdel(bbar, bfoo).intValue());
assertEquals(0, jedis.hdel(bfoo, bfoo).intValue()); assertEquals(0, jedis.hdel(bfoo, bfoo).intValue());
assertEquals(1, jedis.hdel(bfoo, bbar).intValue()); assertEquals(1, jedis.hdel(bfoo, bbar).intValue());
assertEquals(null, jedis.hget(bfoo, bbar)); assertEquals(null, jedis.hget(bfoo, bbar));
} }
@Test @Test
public void hlen() { public void hlen() {
Map<String, String> hash = new HashMap<String, String>(); Map<String, String> hash = new HashMap<String, String>();
hash.put("bar", "car"); hash.put("bar", "car");
hash.put("car", "bar"); hash.put("car", "bar");
jedis.hmset("foo", hash); jedis.hmset("foo", hash);
assertEquals(0, jedis.hlen("bar").intValue()); assertEquals(0, jedis.hlen("bar").intValue());
assertEquals(2, jedis.hlen("foo").intValue()); assertEquals(2, jedis.hlen("foo").intValue());
// Binary // Binary
Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>(); Map<byte[], byte[]> bhash = new HashMap<byte[], byte[]>();
bhash.put(bbar, bcar); bhash.put(bbar, bcar);
bhash.put(bcar, bbar); bhash.put(bcar, bbar);
jedis.hmset(bfoo, bhash); jedis.hmset(bfoo, bhash);
assertEquals(0, jedis.hlen(bbar).intValue()); assertEquals(0, jedis.hlen(bbar).intValue());
assertEquals(2, jedis.hlen(bfoo).intValue()); assertEquals(2, jedis.hlen(bfoo).intValue());
} }
@Test @Test
public void hkeys() { public void hkeys() {
Map<String, String> hash = new LinkedHashMap<String, String>(); Map<String, String> hash = new LinkedHashMap<String, String>();
hash.put("bar", "car"); hash.put("bar", "car");
hash.put("car", "bar"); hash.put("car", "bar");
jedis.hmset("foo", hash); jedis.hmset("foo", hash);
Set<String> keys = jedis.hkeys("foo"); Set<String> keys = jedis.hkeys("foo");
Set<String> expected = new LinkedHashSet<String>(); Set<String> expected = new LinkedHashSet<String>();
expected.add("bar"); expected.add("bar");
expected.add("car"); expected.add("car");
assertEquals(expected, keys); assertEquals(expected, keys);
// Binary // Binary
Map<byte[], byte[]> bhash = new LinkedHashMap<byte[], byte[]>(); Map<byte[], byte[]> bhash = new LinkedHashMap<byte[], byte[]>();
bhash.put(bbar, bcar); bhash.put(bbar, bcar);
bhash.put(bcar, bbar); bhash.put(bcar, bbar);
jedis.hmset(bfoo, bhash); jedis.hmset(bfoo, bhash);
Set<byte[]> bkeys = jedis.hkeys(bfoo); Set<byte[]> bkeys = jedis.hkeys(bfoo);
Set<byte[]> bexpected = new LinkedHashSet<byte[]>(); Set<byte[]> bexpected = new LinkedHashSet<byte[]>();
bexpected.add(bbar); bexpected.add(bbar);
bexpected.add(bcar); bexpected.add(bcar);
assertEquals(bexpected, bkeys); assertEquals(bexpected, bkeys);
} }
@Test @Test
public void hvals() { public void hvals() {
Map<String, String> hash = new LinkedHashMap<String, String>(); Map<String, String> hash = new LinkedHashMap<String, String>();
hash.put("bar", "car"); hash.put("bar", "car");
hash.put("car", "bar"); hash.put("car", "bar");
jedis.hmset("foo", hash); jedis.hmset("foo", hash);
List<String> vals = jedis.hvals("foo"); List<String> vals = jedis.hvals("foo");
assertEquals(2, vals.size()); assertEquals(2, vals.size());
assertTrue(vals.contains("bar")); assertTrue(vals.contains("bar"));
assertTrue(vals.contains("car")); assertTrue(vals.contains("car"));
// Binary // Binary
Map<byte[], byte[]> bhash = new LinkedHashMap<byte[], byte[]>(); Map<byte[], byte[]> bhash = new LinkedHashMap<byte[], byte[]>();
bhash.put(bbar, bcar); bhash.put(bbar, bcar);
bhash.put(bcar, bbar); bhash.put(bcar, bbar);
jedis.hmset(bfoo, bhash); jedis.hmset(bfoo, bhash);
List<byte[]> bvals = jedis.hvals(bfoo); List<byte[]> bvals = jedis.hvals(bfoo);
assertEquals(2, bvals.size()); assertEquals(2, bvals.size());
assertTrue(arrayContains(bvals, bbar)); assertTrue(arrayContains(bvals, bbar));
assertTrue(arrayContains(bvals, bcar)); assertTrue(arrayContains(bvals, bcar));
} }
@Test @Test
public void hgetAll() { public void hgetAll() {
Map<String, String> h = new HashMap<String, String>(); Map<String, String> h = new HashMap<String, String>();
h.put("bar", "car"); h.put("bar", "car");
h.put("car", "bar"); h.put("car", "bar");
jedis.hmset("foo", h); jedis.hmset("foo", h);
Map<String, String> hash = jedis.hgetAll("foo"); Map<String, String> hash = jedis.hgetAll("foo");
assertEquals(2, hash.size()); assertEquals(2, hash.size());
assertEquals("car", hash.get("bar")); assertEquals("car", hash.get("bar"));
assertEquals("bar", hash.get("car")); assertEquals("bar", hash.get("car"));
// Binary // Binary
Map<byte[], byte[]> bh = new HashMap<byte[], byte[]>(); Map<byte[], byte[]> bh = new HashMap<byte[], byte[]>();
bh.put(bbar, bcar); bh.put(bbar, bcar);
bh.put(bcar, bbar); bh.put(bcar, bbar);
jedis.hmset(bfoo, bh); jedis.hmset(bfoo, bh);
Map<byte[], byte[]> bhash = jedis.hgetAll(bfoo); Map<byte[], byte[]> bhash = jedis.hgetAll(bfoo);
assertEquals(2, bhash.size()); assertEquals(2, bhash.size());
assertArrayEquals(bcar, bhash.get(bbar)); assertArrayEquals(bcar, bhash.get(bbar));
assertArrayEquals(bbar, bhash.get(bcar)); assertArrayEquals(bbar, bhash.get(bcar));
}
@Test
public void hscan() {
jedis.hset("foo", "b", "b");
jedis.hset("foo", "a", "a");
ScanResult<Map.Entry<String, String>> result = jedis.hscan("foo", 0);
assertEquals(0, result.getCursor());
assertFalse(result.getResult().isEmpty());
}
@Test
public void hscanMatch() {
ScanParams params = new ScanParams();
params.match("a*");
jedis.hset("foo", "b", "b");
jedis.hset("foo", "a", "a");
jedis.hset("foo", "aa", "aa");
ScanResult<Map.Entry<String, String>> result = jedis.hscan("foo", 0, params);
assertEquals(0, result.getCursor());
assertFalse(result.getResult().isEmpty());
}
@Test
public void hscanCount() {
ScanParams params = new ScanParams();
params.count(2);
for (int i = 0; i < 10; i++) {
jedis.hset("foo", "a" + i, "a" + i);
}
ScanResult<Map.Entry<String, String>> result = jedis.hscan("foo", 0, params);
assertFalse(result.getResult().isEmpty());
} }
} }

39
src/test/java/redis/clients/jedis/tests/commands/SetCommandsTest.java
View File

@@ -2,10 +2,14 @@ package redis.clients.jedis.tests.commands;
import java.util.Arrays; import java.util.Arrays;
import java.util.HashSet; import java.util.HashSet;
import java.util.Map;
import java.util.Set; import java.util.Set;
import org.junit.Test; import org.junit.Test;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
public class SetCommandsTest extends JedisCommandTestBase { public class SetCommandsTest extends JedisCommandTestBase {
final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 }; final byte[] bfoo = { 0x01, 0x02, 0x03, 0x04 };
final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 }; final byte[] bbar = { 0x05, 0x06, 0x07, 0x08 };
@@ -448,7 +452,40 @@ public class SetCommandsTest extends JedisCommandTestBase {
bmember = jedis.srandmember(bbar); bmember = jedis.srandmember(bbar);
assertNull(bmember); assertNull(bmember);
} }
@Test
public void sscan() {
jedis.sadd("foo", "a", "b");
ScanResult<String> result = jedis.sscan("foo", 0);
assertEquals(0, result.getCursor());
assertFalse(result.getResult().isEmpty());
}
@Test
public void sscanMatch() {
ScanParams params = new ScanParams();
params.match("a*");
jedis.sadd("foo", "b", "a", "aa");
ScanResult<String> result = jedis.sscan("foo", 0, params);
assertEquals(0, result.getCursor());
assertFalse(result.getResult().isEmpty());
}
@Test
public void sscanCount() {
ScanParams params = new ScanParams();
params.count(2);
jedis.sadd("foo", "a1", "a2", "a3", "a4", "a5");
ScanResult<String> result = jedis.sscan("foo", 0, params);
assertFalse(result.getResult().isEmpty());
}
} }

44
src/test/java/redis/clients/jedis/tests/commands/SortedSetCommandsTest.java
View File

@@ -5,6 +5,8 @@ import java.util.Set;
import org.junit.Test; import org.junit.Test;
import redis.clients.jedis.ScanParams;
import redis.clients.jedis.ScanResult;
import redis.clients.jedis.Tuple; import redis.clients.jedis.Tuple;
import redis.clients.jedis.ZParams; import redis.clients.jedis.ZParams;
import redis.clients.util.SafeEncoder; import redis.clients.util.SafeEncoder;
@@ -885,4 +887,46 @@ public class SortedSetCommandsTest extends JedisCommandTestBase {
assertEquals(1, t2.compareTo(t1)); assertEquals(1, t2.compareTo(t1));
assertEquals(0, t2.compareTo(t2)); assertEquals(0, t2.compareTo(t2));
} }
@Test
public void zscan() {
jedis.zadd("foo", 1, "a");
jedis.zadd("foo", 2, "b");
ScanResult<Tuple> result = jedis.zscan("foo", 0);
assertEquals(0, result.getCursor());
assertFalse(result.getResult().isEmpty());
}
@Test
public void zscanMatch() {
ScanParams params = new ScanParams();
params.match("a*");
jedis.zadd("foo", 2, "b");
jedis.zadd("foo", 1, "a");
jedis.zadd("foo", 11, "aa");
ScanResult<Tuple> result = jedis.zscan("foo", 0, params);
assertEquals(0, result.getCursor());
assertFalse(result.getResult().isEmpty());
}
@Test
public void zscanCount() {
ScanParams params = new ScanParams();
params.count(2);
jedis.zadd("foo", 1, "a1");
jedis.zadd("foo", 2, "a2");
jedis.zadd("foo", 3, "a3");
jedis.zadd("foo", 4, "a4");
jedis.zadd("foo", 5, "a5");
ScanResult<Tuple> result = jedis.zscan("foo", 0, params);
assertFalse(result.getResult().isEmpty());
}
} }