com.fiftyonred.mock_jedis.MockPipeline Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of mock-jedis Show documentation
Mock Jedis is a library for mocking out Jedis clients
The newest version!
package com.fiftyonred.mock_jedis;

import redis.clients.jedis.*;
import redis.clients.jedis.exceptions.JedisDataException;

import java.util.*;

import static com.fiftyonred.mock_jedis.DataContainer.CHARSET;

public class MockPipeline extends Pipeline {

	private static final byte[] STRING_TYPE = "string".getBytes(CHARSET);
	private static final byte[] LIST_TYPE = "list".getBytes(CHARSET);
	private static final byte[] SET_TYPE = "set".getBytes(CHARSET);
	private static final byte[] NONE_TYPE = "none".getBytes(CHARSET);
	private static final byte[] OK_RESPONSE  = "OK".getBytes(CHARSET);
	private static final byte[] PONG_RESPONSE = "PONG".getBytes(CHARSET);

	private final MockStorage mockStorage;

	public MockPipeline() {
		mockStorage = new MockStorage();
	}

	public int getCurrentDB() {
		return mockStorage.getCurrentDB();
	}

	protected static  T getRandomElementFromSet(final Set set) {
		return (T) set.toArray()[(int) (Math.random() * set.size())];
	}

	@Override
	public Response ping() {
		final Response response = new Response(BuilderFactory.STRING);
		response.set(PONG_RESPONSE);
		return response;
	}

	@Override
	public Response echo(final String string) {
		final Response response = new Response(BuilderFactory.STRING);
		response.set(echo(string.getBytes(CHARSET)).get());
		return response;
	}

	@Override
	public Response echo(final byte[] string) {
		final Response response = new Response(BuilderFactory.BYTE_ARRAY);
		response.set(string);
		return response;
	}

	@Override
	public Response dbSize() {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.dbSize());
		return response;
	}

	@Override
	public Response flushAll() {
		mockStorage.flushAll();
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response flushDB() {
		mockStorage.flushDB();
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response rename(final String oldkey, final String newkey) {
		mockStorage.rename(DataContainer.from(oldkey), DataContainer.from(newkey));
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response rename(final byte[] oldkey, final byte[] newkey) {
		mockStorage.rename(DataContainer.from(oldkey), DataContainer.from(newkey));
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response renamenx(final String oldkey, final String newkey) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.renamenx(DataContainer.from(oldkey), DataContainer.from(newkey)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response renamenx(final byte[] oldkey, final byte[] newkey) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.renamenx(DataContainer.from(oldkey), DataContainer.from(newkey)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response set(final String key, final String value) {
		mockStorage.set(DataContainer.from(key), DataContainer.from(value));
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response set(final byte[] key, final byte[] value) {
		mockStorage.set(DataContainer.from(key), DataContainer.from(value));
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response setnx(final String key, final String value) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.setnx(DataContainer.from(key), DataContainer.from(value)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response setnx(final byte[] key, final byte[] value) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.setnx(DataContainer.from(key), DataContainer.from(value)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response get(final String key) {
		final Response response = new Response(BuilderFactory.STRING);
		final DataContainer result = mockStorage.get(DataContainer.from(key));
		response.set(DataContainer.toBytes(result));
		return response;
	}

	@Override
	public Response get(final byte[] key) {
		final Response response = new Response(BuilderFactory.BYTE_ARRAY);
		final DataContainer result = mockStorage.get(DataContainer.from(key));
		response.set(DataContainer.toBytes(result));
		return response;
	}

	@Override
	public Response getSet(final String key, final String value) {
		final Response response = new Response(BuilderFactory.STRING);
		final DataContainer result = mockStorage.getSet(DataContainer.from(key), DataContainer.from(value));
		response.set(result == null ? null : result.getBytes());
		return response;
	}

	@Override
	public Response getSet(final byte[] key, final byte[] value) {
		final Response response = new Response(BuilderFactory.BYTE_ARRAY);
		final DataContainer result = mockStorage.getSet(DataContainer.from(key), DataContainer.from(value));
		response.set(result == null ? null : result.getBytes());
		return response;
	}

	@Override
	public Response dump(final byte[] key) {
		return get(key);
	}

	@Override
	public Response dump(final String key) {
		return get(key.getBytes(CHARSET));
	}

	@Override
	public Response restore(final String key, final int ttl, final byte[] serializedValue) {
		return setex(key.getBytes(CHARSET), ttl, serializedValue);
	}

	@Override
	public Response restore(final byte[] key, final int ttl, final byte[] serializedValue) {
		return setex(key, ttl, serializedValue);
	}

	@Override
	public Response exists(final String key) {
		final Response response = new Response(BuilderFactory.BOOLEAN);
		response.set(mockStorage.exists(DataContainer.from(key)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response exists(final byte[] key) {
		final Response response = new Response(BuilderFactory.BOOLEAN);
		response.set(mockStorage.exists(DataContainer.from(key)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response type(final String key) {
		final KeyType type = mockStorage.type(DataContainer.from(key));
		final Response response = new Response(BuilderFactory.STRING);
		if (type == null) {
			response.set(NONE_TYPE);
			return response;
		}
		switch (type) {
			case STRING:
				response.set(STRING_TYPE);
				break;
			case LIST:
				response.set(LIST_TYPE);
				break;
			case SET:
				response.set(SET_TYPE);
				break;
			default:
				response.set(NONE_TYPE);
		}
		return response;
	}

	@Override
	public Response type(final byte[] key) {
		final KeyType type = mockStorage.type(DataContainer.from(key));
		final Response response = new Response(BuilderFactory.STRING);
		if (type == null) {
			response.set(NONE_TYPE);
			return response;
		}
		switch (type) {
			case STRING:
				response.set(STRING_TYPE);
				break;
			case LIST:
				response.set(LIST_TYPE);
				break;
			case SET:
				response.set(SET_TYPE);
				break;
			default:
				response.set(NONE_TYPE);
		}
		return response;
	}

	@Override
	public Response move(final String key, final int dbIndex) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.move(DataContainer.from(key), dbIndex) ? 1L : 0L);
		return response;
	}

	@Override
	public Response move(final byte[] key, final int dbIndex) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.move(DataContainer.from(key), dbIndex) ? 1L : 0L);
		return response;
	}

	@Override
	public Response randomKey() {
		final DataContainer result = mockStorage.randomKey();
		final Response response = new Response(BuilderFactory.STRING);
		response.set(result == null ? null : result.getBytes());
		return response;
	}

	@Override
	public Response randomKeyBinary() {
		final Response response = new Response(BuilderFactory.BYTE_ARRAY);
		final DataContainer result = mockStorage.randomKey();
		response.set(result == null ? null : result.getBytes());
		return response;
	}

	@Override
	public Response select(final int dbIndex) {
		mockStorage.select(dbIndex);
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response setex(final String key, final int seconds, final String value) {
		return psetex(key, seconds * 1000, value);
	}

	@Override
	public Response setex(final byte[] key, final int seconds, final byte[] value) {
		return psetex(key, seconds * 1000, value);
	}

	@Override
	public Response psetex(final String key, final int milliseconds, final String value) {
		mockStorage.psetex(DataContainer.from(key), milliseconds, DataContainer.from(value));
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response psetex(final byte[] key, final int milliseconds, final byte[] value) {
		mockStorage.psetex(DataContainer.from(key), milliseconds, DataContainer.from(value));
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response expire(final String key, final int seconds) {
		return expireAt(key, System.currentTimeMillis() / 1000 + seconds);
	}

	@Override
	public Response expire(final byte[] key, final int seconds) {
		return expireAt(key, System.currentTimeMillis() / 1000 + seconds);
	}

	@Override
	public Response expireAt(final String key, final long unixTime) {
		return pexpireAt(key, unixTime * 1000L);
	}

	@Override
	public Response expireAt(final byte[] key, final long unixTime) {
		return pexpireAt(key, unixTime * 1000L);
	}

	@Override
	public Response pexpire(final String key, final int milliseconds) {
		return pexpireAt(key, System.currentTimeMillis() + milliseconds);
	}

	@Override
	public Response pexpire(final byte[] key, final int milliseconds) {
		return pexpireAt(key, System.currentTimeMillis() + milliseconds);
	}

	@Override
	public Response pexpire(final String key, final long milliseconds) {
		return pexpireAt(key, System.currentTimeMillis() + milliseconds);
	}

	@Override
	public Response pexpire(final byte[] key, final long milliseconds) {
		return pexpireAt(key, System.currentTimeMillis() + milliseconds);
	}

	@Override
	public Response pexpireAt(final String key, final long millisecondsTimestamp) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.pexpireAt(DataContainer.from(key), millisecondsTimestamp) ? 1L : 0L);
		return response;
	}

	@Override
	public Response pexpireAt(final byte[] key, final long millisecondsTimestamp) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.pexpireAt(DataContainer.from(key), millisecondsTimestamp) ? 1L : 0L);
		return response;
	}

	@Override
	public Response ttl(final String key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.ttl(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response ttl(final byte[] key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.ttl(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response append(final String key, final String value) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.append(DataContainer.from(key), DataContainer.from(value)));
		return response;
	}

	@Override
	public Response append(final byte[] key, final byte[] value) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.append(DataContainer.from(key), DataContainer.from(value)));
		return response;
	}

	@Override
	public Response pttl(final String key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.pttl(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response pttl(final byte[] key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.pttl(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response persist(final String key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.persist(DataContainer.from(key)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response persist(final byte[] key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.persist(DataContainer.from(key)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response> mget(final String... keys) {
		final Response> response = new Response>(BuilderFactory.STRING_LIST);

		final List result = new ArrayList(keys.length);
		for (final DataContainer val : mockStorage.mget(DataContainer.from(keys))) {
			result.add(val == null ? null : val.getBytes());
		}
		response.set(result);
		return response;
	}

	@Override
	public Response> mget(final byte[]... keys) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_LIST);

		final List result = new ArrayList(keys.length);
		for (final DataContainer val : mockStorage.mget(DataContainer.from(keys))) {
			result.add(val == null ? null : val.getBytes());
		}
		response.set(result);
		return response;
	}

	@Override
	public Response mset(final String... keysvalues) {
		mockStorage.mset(DataContainer.from(keysvalues));
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response mset(final byte[]... keysvalues) {
		mockStorage.mset(DataContainer.from(keysvalues));
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response msetnx(final String... keysvalues) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.msetnx(DataContainer.from(keysvalues)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response msetnx(final byte[]... keysvalues) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.msetnx(DataContainer.from(keysvalues)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response decr(final String key) {
		return decrBy(key, 1L);
	}

	@Override
	public Response decr(final byte[] key) {
		return decrBy(key, 1L);
	}

	@Override
	public Response decrBy(final String key, final long integer) {
		return incrBy(key, -integer);
	}

	@Override
	public Response decrBy(final byte[] key, final long integer) {
		return incrBy(key, -integer);
	}

	@Override
	public Response incr(final String key) {
		return incrBy(key, 1L);
	}

	@Override
	public Response incr(final byte[] key) {
		return incrBy(key, 1L);
	}

	@Override
	public Response incrBy(final String key, final long integer) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.incrBy(DataContainer.from(key), integer));
		return response;
	}

	@Override
	public Response incrBy(final byte[] key, final long integer) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.incrBy(DataContainer.from(key), integer));
		return response;
	}

	@Override
	public Response incrByFloat(final String key, final double increment) {
		final Response response = new Response(BuilderFactory.DOUBLE);
		response.set(mockStorage.incrByFloat(DataContainer.from(key), increment).getBytes());
		return response;
	}

	@Override
	public Response incrByFloat(final byte[] key, final double increment) {
		final Response response = new Response(BuilderFactory.DOUBLE);
		response.set(mockStorage.incrByFloat(DataContainer.from(key), increment).getBytes());
		return response;
	}

	@Override
	public Response> sort(final String key) {
		return sort(key, new SortingParams());
	}

	@Override
	public Response sort(final String key, final String dstkey) {
		return sort(key, new SortingParams(), dstkey);
	}

	@Override
	public Response sort(final byte[] key, final byte[] dstkey) {
		return sort(key, new SortingParams(), dstkey);
	}

	private static Comparator makeComparator(final Collection params) {
		final Comparator comparator;
		final int direction = params.contains(Protocol.Keyword.DESC.name().toLowerCase()) ? -1 : 1;
		if (params.contains(Protocol.Keyword.ALPHA.name().toLowerCase())) {
			comparator = new Comparator() {
				@Override
				public int compare(final DataContainer o1, final DataContainer o2) {
					return o1.compareTo(o2) * direction;
				}
			};
		} else {
			comparator = new Comparator() {
				@Override
				public int compare(final DataContainer o1, final DataContainer o2) {
					final Long i1, i2;
					try {
						i1 = Long.parseLong(o1.getString());
						i2 = Long.parseLong(o2.getString());
					} catch (final NumberFormatException e) {
						throw new JedisDataException("ERR One or more scores can't be converted into double");
					}
					return i1.compareTo(i2) * direction;
				}
			};
		}
		return comparator;
	}

	@Override
	public Response> sort(final String key, final SortingParams sortingParameters) {
		final Response> response = new Response>(BuilderFactory.STRING_LIST);
		List sortedList = mockStorage.sort(DataContainer.from(key), sortingParameters);
		response.set(DataContainer.toBytes(sortedList));
		return response;
	}

	@Override
	public Response> sort(final byte[] key, final SortingParams sortingParameters) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_LIST);
		List sortedList = mockStorage.sort(DataContainer.from(key), sortingParameters);
		response.set(DataContainer.toBytes(sortedList));
		return response;
	}

	@Override
	public Response sort(final String key, final SortingParams sortingParameters, final String dstkey) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.sort(DataContainer.from(key), sortingParameters, DataContainer.from(dstkey)));
		return response;
	}

	@Override
	public Response sort(final byte[] key, final SortingParams sortingParameters, final byte[] dstkey) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.sort(DataContainer.from(key), sortingParameters, DataContainer.from(dstkey)));
		return response;
	}

	@Override
	public Response> sort(final byte[] key) {
		return sort(key, new SortingParams());
	}

	@Override
	public Response strlen(final String key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.strlen(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response strlen(final byte[] key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.strlen(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response del(final String... keys) {
		final Response response = new Response(BuilderFactory.LONG);
		long result = 0L;
		for (final String key : keys) {
			result += del(key).get();
		}

		response.set(result);
		return response;
	}

	@Override
	public Response del(final byte[]... keys) {
		final Response response = new Response(BuilderFactory.LONG);
		long result = 0L;
		for (final byte[] key : keys) {
			result += del(key).get();
		}

		response.set(result);
		return response;
	}

	@Override
	public Response del(final String key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.del(DataContainer.from(key)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response del(final byte[] key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.del(DataContainer.from(key)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response hget(final String key, final String field) {
		final Response response = new Response(BuilderFactory.STRING);
		final DataContainer result = mockStorage.hget(DataContainer.from(key), DataContainer.from(field));
		response.set(result == null ? null : result.getBytes());
		return response;
	}

	@Override
	public Response hget(final byte[] key, final byte[] field) {
		final Response response = new Response(BuilderFactory.BYTE_ARRAY);
		final DataContainer result = mockStorage.hget(DataContainer.from(key), DataContainer.from(field));
		response.set(result == null ? null : result.getBytes());
		return response;
	}

	@Override
	public Response> hgetAll(final String key) {
		final Response> response = new Response>(BuilderFactory.STRING_MAP);
		final Map result = mockStorage.hgetAll(DataContainer.from(key));

		if (result != null) {
			final List encodedResult = new ArrayList(result.size());
			for (final Map.Entry e : result.entrySet()) {
				encodedResult.add(e.getKey().getBytes());
				encodedResult.add(e.getValue().getBytes());
			}
			response.set(encodedResult);
		} else {
			response.set(new ArrayList(0));
		}
		return response;
	}

	@Override
	public Response> hgetAll(final byte[] key) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_MAP);
		final Map result = mockStorage.hgetAll(DataContainer.from(key));

		if (result != null) {
			final List encodedResult = new ArrayList(result.size());
			for (final Map.Entry e : result.entrySet()) {
				encodedResult.add(e.getKey().getBytes());
				encodedResult.add(e.getValue().getBytes());
			}
			response.set(encodedResult);
		} else {
			response.set(new ArrayList(0));
		}
		return response;
	}

	@Override
	public Response> hkeys(final String key) {
		final Response> response = new Response>(BuilderFactory.STRING_SET);
		final Set result = mockStorage.hkeys(DataContainer.from(key));
		response.set(result == null ? new ArrayList(0) : DataContainer.toBytes(result));
		return response;
	}

	@Override
	public Response> hkeys(final byte[] key) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_ZSET);
		final Set result = mockStorage.hkeys(DataContainer.from(key));
		response.set(result == null ? new ArrayList(0) : DataContainer.toBytes(result));
		return response;
	}

	@Override
	public Response> hvals(final String key) {
		final Response> response = new Response>(BuilderFactory.STRING_LIST);
		final Collection result = mockStorage.hvals(DataContainer.from(key));
		response.set(result == null ? new ArrayList(0) : DataContainer.toBytes(result));
		return response;
	}

	@Override
	public Response> hvals(final byte[] key) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_LIST);
		final Collection result = mockStorage.hvals(DataContainer.from(key));
		response.set(result == null ? new ArrayList(0) : DataContainer.toBytes(result));
		return response;
	}

	@Override
	public Response hset(final String key, final String field, final String value) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.hset(DataContainer.from(key), DataContainer.from(field), DataContainer.from(value)) ? 1L : 0L);
		return response;

	}

	@Override
	public Response hset(final byte[] key, final byte[] field, final byte[] value) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.hset(DataContainer.from(key), DataContainer.from(field), DataContainer.from(value)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response hsetnx(final String key, final String field, final String value) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.hsetnx(DataContainer.from(key), DataContainer.from(field), DataContainer.from(value)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response hsetnx(final byte[] key, final byte[] field, final byte[] value) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.hsetnx(DataContainer.from(key), DataContainer.from(field), DataContainer.from(value)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response> hmget(final String key, final String... fields) {
		final Response> response = new Response>(BuilderFactory.STRING_LIST);
		final List result = new ArrayList(fields.length);
		final List hash = mockStorage.hmget(DataContainer.from(key), DataContainer.from(fields));
		if (hash == null) {
			for (final String ignored : fields) {
				result.add(null);
			}
		} else {
			for (final DataContainer h : hash) {
				result.add(h == null ? null : h.getBytes());
			}
		}
		response.set(result);
		return response;
	}

	@Override
	public Response> hmget(final byte[] key, final byte[]... fields) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_LIST);
		final List result = new ArrayList(fields.length);
		final List hash = mockStorage.hmget(DataContainer.from(key), DataContainer.from(fields));
		if (hash == null) {
			for (final byte[] ignored : fields) {
				result.add(null);
			}
		} else {
			for (final DataContainer h : hash) {
				result.add(h == null ? null : h.getBytes());
			}
		}
		response.set(result);
		return response;
	}

	@Override
	public Response hmset(final String key, final Map hash) {
		mockStorage.hmset(DataContainer.from(key), DataContainer.fromStringMap(hash));
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response hmset(final byte[] key, final Map hash) {
		mockStorage.hmset(DataContainer.from(key), DataContainer.fromByteMap(hash));
		final Response response = new Response(BuilderFactory.STRING);
		response.set(OK_RESPONSE);
		return response;
	}

	@Override
	public Response hincrBy(final String key, final String field, final long value) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.hincrBy(DataContainer.from(key), DataContainer.from(field), value));
		return response;
	}

	@Override
	public Response hincrBy(final byte[] key, final byte[] field, final long value) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.hincrBy(DataContainer.from(key), DataContainer.from(field), value));
		return response;
	}

	@Override
	public Response hincrByFloat(final String key, final String field, final double increment) {
		final Response response = new Response(BuilderFactory.DOUBLE);
		response.set(mockStorage.hincrByFloat(DataContainer.from(key), DataContainer.from(field), increment).getBytes());
		return response;
	}

	@Override
	public Response hincrByFloat(final byte[] key, final byte[] field, final double increment) {
		final Response response = new Response(BuilderFactory.DOUBLE);
		response.set(mockStorage.hincrByFloat(DataContainer.from(key), DataContainer.from(field), increment).getBytes());
		return response;
	}

	@Override
	public Response hdel(final String key, final String... field) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.hdel(DataContainer.from(key), DataContainer.from(field)));
		return response;
	}

	@Override
	public Response hdel(final byte[] key, final byte[]... field) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.hdel(DataContainer.from(key), DataContainer.from(field)));
		return response;
	}

	@Override
	public Response hexists(final String key, final String field) {
		final Response response = new Response(BuilderFactory.BOOLEAN);
		response.set(mockStorage.hexists(DataContainer.from(key), DataContainer.from(field)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response hexists(final byte[] key, final byte[] field) {
		final Response response = new Response(BuilderFactory.BOOLEAN);
		response.set(mockStorage.hexists(DataContainer.from(key), DataContainer.from(field)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response hlen(final String key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.hlen(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response hlen(final byte[] key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.hlen(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response lpush(final String key, final String... string) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.lpush(DataContainer.from(key), DataContainer.from(string)));
		return response;
	}

	@Override
	public Response lpush(final byte[] key, final byte[]... string) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.lpush(DataContainer.from(key), DataContainer.from(string)));
		return response;
	}

	@Override
	public Response lpop(final String key) {
		final Response response = new Response(BuilderFactory.STRING);
		final DataContainer result = mockStorage.lpop(DataContainer.from(key));
		response.set(result == null ? null : result.getBytes());
		return response;
	}

	@Override
	public Response lpop(final byte[] key) {
		final Response response = new Response(BuilderFactory.BYTE_ARRAY);
		final DataContainer result = mockStorage.lpop(DataContainer.from(key));
		response.set(result == null ? null : result.getBytes());
		return response;
	}

	@Override
	public Response llen(final String key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.llen(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response llen(final byte[] key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.llen(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response> lrange(final String key, final long start, final long end) {
		final Response> response = new Response>(BuilderFactory.STRING_LIST);
		response.set(DataContainer.toBytes(mockStorage.lrange(DataContainer.from(key), start, end)));
		return response;
	}

	@Override
	public Response> lrange(final byte[] key, final long start, final long end) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_LIST);
		response.set(DataContainer.toBytes(mockStorage.lrange(DataContainer.from(key), start, end)));
		return response;
	}

	@Override
	public void sync() {
		// do nothing
	}

	@Override
	public Response> keys(final String pattern) {
		final Response> response = new Response>(BuilderFactory.STRING_SET);
		response.set(DataContainer.toBytes(mockStorage.keys(DataContainer.from(pattern))));
		return response;
	}

	@Override
	public Response> keys(final byte[] pattern) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_ZSET);
		response.set(DataContainer.toBytes(mockStorage.keys(DataContainer.from(pattern))));
		return response;
	}

	@Override
	public Response sadd(final String key, final String... member) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.sadd(DataContainer.from(key), DataContainer.from(member)));
		return response;
	}

	@Override
	public Response sadd(final byte[] key, final byte[]... member) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.sadd(DataContainer.from(key), DataContainer.from(member)));
		return response;
	}

	@Override
	public Response srem(final String key, final String... member) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.srem(DataContainer.from(key), DataContainer.from(member)));
		return response;
	}

	@Override
	public Response srem(final byte[] key, final byte[]... member) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.srem(DataContainer.from(key), DataContainer.from(member)));
		return response;
	}

	@Override
	public Response scard(final String key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.scard(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response scard(final byte[] key) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.scard(DataContainer.from(key)));
		return response;
	}

	@Override
	public Response> sdiff(final String... keys) {
		final Response> response = new Response>(BuilderFactory.STRING_SET);
		response.set(
				DataContainer.toBytes(
						mockStorage.sdiff(DataContainer.from(keys))
				)
		);
		return response;
	}

	@Override
	public Response> sdiff(final byte[]... keys) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_ZSET);
		response.set(
				DataContainer.toBytes(
						mockStorage.sdiff(DataContainer.from(keys))
				)
		);
		return response;
	}

	@Override
	public Response sdiffstore(final String dstkey, final String... keys) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.sdiffstore(DataContainer.from(dstkey), DataContainer.from(keys)));
		return response;
	}

	@Override
	public Response sdiffstore(final byte[] dstkey, final byte[]... keys) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.sdiffstore(DataContainer.from(dstkey), DataContainer.from(keys)));
		return response;
	}

	@Override
	public Response> sinter(final String... keys) {
		final Response> response = new Response>(BuilderFactory.STRING_SET);
		response.set(
				DataContainer.toBytes(
						mockStorage.sinter(DataContainer.from(keys))
				)
		);
		return response;
	}

	@Override
	public Response> sinter(final byte[]... keys) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_ZSET);
		response.set(
				DataContainer.toBytes(
						mockStorage.sinter(DataContainer.from(keys))
				)
		);
		return response;
	}

	@Override
	public Response sinterstore(final String dstkey, final String... keys) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.sinterstore(DataContainer.from(dstkey), DataContainer.from(keys)));
		return response;
	}

	@Override
	public Response sinterstore(final byte[] dstkey, final byte[]... keys) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.sinterstore(DataContainer.from(dstkey), DataContainer.from(keys)));
		return response;
	}

	@Override
	public Response sismember(final String key, final String member) {
		final Response response = new Response(BuilderFactory.BOOLEAN);
		response.set(mockStorage.sismember(DataContainer.from(key), DataContainer.from(member)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response sismember(final byte[] key, final byte[] member) {
		final Response response = new Response(BuilderFactory.BOOLEAN);
		response.set(mockStorage.sismember(DataContainer.from(key), DataContainer.from(member)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response smove(final String srckey, final String dstkey, final String member) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.smove(DataContainer.from(srckey), DataContainer.from(dstkey), DataContainer.from(member)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response smove(final byte[] srckey, final byte[] dstkey, final byte[] member) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set(mockStorage.smove(DataContainer.from(srckey), DataContainer.from(dstkey), DataContainer.from(member)) ? 1L : 0L);
		return response;
	}

	@Override
	public Response spop(final String key) {
		final Response response = new Response(BuilderFactory.STRING);
		response.set(
				DataContainer.toBytes(
						mockStorage.spop(DataContainer.from(key))
				)
		);
		return response;
	}

	@Override
	public Response spop(final byte[] key) {
		final Response response = new Response(BuilderFactory.BYTE_ARRAY);
		response.set(
				DataContainer.toBytes(
						mockStorage.spop(DataContainer.from(key))
				)
		);
		return response;
	}

	@Override
	public Response srandmember(final String key) {
		final Response response = new Response(BuilderFactory.STRING);
		final DataContainer result = mockStorage.srandmember(DataContainer.from(key));
		response.set(result == null ? null : result.getBytes());
		return response;
	}

	@Override
	public Response srandmember(final byte[] key) {
		final Response response = new Response(BuilderFactory.BYTE_ARRAY);
		final DataContainer result = mockStorage.srandmember(DataContainer.from(key));
		response.set(result == null ? null : result.getBytes());
		return response;
	}

	@Override
	public Response> smembers(final String key) {
		final Response> response = new Response>(BuilderFactory.STRING_SET);
		final Set members = mockStorage.smembers(DataContainer.from(key));
		response.set(DataContainer.toBytes(members));

		return response;
	}

	@Override
	public Response> smembers(final byte[] key) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_ZSET);
		final Set members = mockStorage.smembers(DataContainer.from(key));
		response.set(DataContainer.toBytes(members));

		return response;
	}

	@Override
	public Response> sunion(final String... keys) {
		final Response> response = new Response>(BuilderFactory.STRING_SET);
		response.set(DataContainer.toBytes(mockStorage.sunion(DataContainer.from(keys))));
		return response;
	}

	@Override
	public Response> sunion(final byte[]... keys) {
		final Response> response = new Response>(BuilderFactory.BYTE_ARRAY_ZSET);
		response.set(DataContainer.toBytes(mockStorage.sunion(DataContainer.from(keys))));
		return response;
	}

	@Override
	public Response sunionstore(final String dstkey, final String... keys) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.sunionstore(DataContainer.from(dstkey), DataContainer.from(keys)));
		return response;
	}

	@Override
	public Response sunionstore(final byte[] dstkey, final byte[]... keys) {
		final Response response = new Response(BuilderFactory.LONG);
		response.set((long) mockStorage.sunionstore(DataContainer.from(dstkey), DataContainer.from(keys)));
		return response;
	}
}