RedisMap iml

src/main/java/org/redis/RedisMap.java

@@ -0,0 +1,105 @@
+package org.redis;
+
+import redis.clients.jedis.Jedis;
+
+import java.util.AbstractMap;
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+public class RedisMap extends AbstractMap <String, String> {
+    private static final String PREFIX = "redis-map:";
+
+    private final Jedis jedis;
+
+    public RedisMap(Jedis jedis) {
+        this.jedis = jedis;
+    }
+
+    private String buildKey(Object key) {
+        return PREFIX + key;
+    }
+
+
+    @Override
+    public String put(String key, String value) {
+
+        String redisKey = buildKey(key);
+
+        String oldValue = jedis.get(redisKey);
+
+        jedis.set(redisKey, value);
+
+        return oldValue;
+    }
+
+    @Override
+    public String get(Object key) {
+        return jedis.get(buildKey(key));
+    }
+
+    @Override
+    public String remove(Object key) {
+
+        String redisKey = buildKey(key);
+
+        String oldValue = jedis.get(redisKey);
+
+        jedis.del(redisKey);
+
+        return oldValue;
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return jedis.exists(buildKey(key));
+    }
+
+    @Override
+    public int size() {
+        return jedis.keys(PREFIX + "*").size();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return size() == 0;
+    }
+
+    @Override
+    public void clear() {
+
+        Set<String> keys = jedis.keys(PREFIX + "*");
+
+        if (!keys.isEmpty()) {
+            jedis.del(keys.toArray(new String[0]));
+        }
+    }
+
+    @Override
+    public Set<String> keySet() {
+
+        Set<String> keys = jedis.keys(PREFIX + "*");
+
+        return keys.stream()
+                .map(key -> key.replace(PREFIX, ""))
+                .collect(Collectors.toSet());
+    }
+
+    @Override
+    public Collection<String> values() {
+
+        return keySet().stream()
+                .map(this::get)
+                .toList();
+    }
+
+    @Override
+    public Set<Entry<String, String>> entrySet() {
+
+        return keySet().stream()
+                .map(key -> Map.entry(key, get(key)))
+                .collect(Collectors.toSet());
+    }
+
+}

src/test/java/RedisMapTest.java

@@ -0,0 +1,148 @@
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.redis.RedisMap;
+import redis.clients.jedis.Jedis;
+
+import java.util.Collection;
+import java.util.Map;
+import java.util.Set;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class RedisMapTest {
+
+    private RedisMap map;
+
+    @BeforeEach
+    void setUp() {
+
+        Jedis jedis = new Jedis("localhost", 6379);
+
+        jedis.flushDB();
+
+        map = new RedisMap(jedis);
+    }
+
+    @Test
+    void putShouldStoreValue() {
+
+        map.put("name", "Alex");
+
+        assertEquals("Alex", map.get("name"));
+    }
+
+    @Test
+    void removeShouldDeleteValue() {
+
+        map.put("name", "Alex");
+
+        String removed = map.remove("name");
+
+        assertEquals("Alex", removed);
+
+        assertEquals(null, map.get("name"));
+    }
+
+    @Test
+    void containsKeyShouldReturnTrueWhenKeyExists() {
+
+        map.put("name", "Alex");
+
+        assertEquals(true, map.containsKey("name"));
+    }
+
+    @Test
+    void containsKeyShouldReturnFalseWhenKeyDoesNotExist() {
+
+        assertEquals(false, map.containsKey("unknown"));
+    }
+
+    @Test
+    void sizeShouldReturnNumberOfElements() {
+
+        map.put("a", "1");
+        map.put("b", "2");
+
+        assertEquals(2, map.size());
+    }
+
+    @Test
+    void isEmptyShouldReturnTrueForEmptyMap() {
+
+        assertEquals(true, map.isEmpty());
+    }
+
+    @Test
+    void isEmptyShouldReturnFalseForNonEmptyMap() {
+
+        map.put("a", "1");
+
+        assertEquals(false, map.isEmpty());
+    }
+
+    @Test
+    void clearShouldRemoveAllElements() {
+
+        map.put("a", "1");
+        map.put("b", "2");
+
+        map.clear();
+
+        assertEquals(0, map.size());
+    }
+
+    @Test
+    void keySetShouldReturnAllKeys() {
+
+        map.put("name", "Alex");
+        map.put("age", "25");
+
+        Set<String> keys = map.keySet();
+
+        assertEquals(2, keys.size());
+
+        assertEquals(true, keys.contains("name"));
+        assertEquals(true, keys.contains("age"));
+    }
+
+    @Test
+    void valuesShouldReturnAllValues() {
+
+        map.put("name", "Alex");
+        map.put("age", "25");
+
+        Collection<String> values = map.values();
+
+        assertEquals(2, values.size());
+
+        assertEquals(true, values.contains("Alex"));
+        assertEquals(true, values.contains("25"));
+    }
+
+    @Test
+    void entrySetShouldReturnAllEntries() {
+
+        map.put("name", "Alex");
+
+        Set<Map.Entry<String, String>> entries = map.entrySet();
+
+        assertEquals(1, entries.size());
+
+        Map.Entry<String, String> entry = entries.iterator().next();
+
+        assertEquals("name", entry.getKey());
+        assertEquals("Alex", entry.getValue());
+    }
+
+    @Test
+    void putShouldReturnOldValue() {
+
+        map.put("name", "Alex");
+
+        String old = map.put("name", "Bob");
+
+        assertEquals("Alex", old);
+
+        assertEquals("Bob", map.get("name"));
+    }
+}