implement Map for Resis, and tests

src/main/java/org/redis/Main.java

@@ -1,7 +1,26 @@
 package org.redis;
 
+import org.redis.map.RedisMap;
+import redis.clients.jedis.Jedis;
+
 public class Main {
     public static void main(String[] args) {
-        System.out.println("Hello world!");
+
+        Jedis jedis = new Jedis("localhost", 6379);
+
+        jedis.set("first", "Hello Rediss!");
+
+        String value = jedis.get("first");
+        System.out.println("Value from Redis: " + value);
+
+        RedisMap redisMap = new RedisMap(jedis);
+
+        redisMap.put("first", "Hello Rediss!");
+
+        redisMap.put("second", "Hello Rediss!");
+
+        System.out.println("redisMap.get(\"first\") = " + redisMap.get("first"));
+
+
     }
 }

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

@@ -0,0 +1,135 @@
+package org.redis.map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import redis.clients.jedis.Jedis;
+import redis.clients.jedis.resps.ScanResult;
+
+import java.util.*;
+
+public class RedisMap implements Map<String, String> {
+
+    private static final Logger log = LoggerFactory.getLogger(RedisMap.class);
+    private final Jedis jedis;
+
+    public RedisMap(Jedis jedis) {
+        this.jedis = jedis;
+    }
+
+    @Override
+    public int size() {
+        return (int) jedis.dbSize();
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return jedis.dbSize() == 0;
+    }
+
+    @Override
+    public boolean containsKey(Object key) {
+        return jedis.exists(key.toString());
+    }
+
+    @Override
+    public boolean containsValue(Object value) {
+
+        String cursor = "0";
+
+        do {
+            ScanResult<String> scanResult = jedis.scan(cursor);
+            for (String key : scanResult.getResult()) {
+                String foundValue = jedis.get(key);
+                if (Objects.equals(foundValue, value)) {
+                    log.info("Нашёл ключ: {}", key);
+                    return true;
+                }
+            }
+            cursor = scanResult.getCursor();
+        } while (!"0".equals(cursor));
+
+        return false;
+    }
+
+    @Override
+    public String get(Object key) {
+        return jedis.get(key.toString());
+    }
+
+    @Override
+    public String put(String key, String value) {
+
+        String oldValue = jedis.get(key);
+        jedis.set(key, value);
+        return oldValue;
+
+    }
+
+    @Override
+    public String remove(Object key) {
+
+        String value = jedis.get(key.toString());
+        jedis.del(key.toString());
+        return value;
+
+    }
+
+    @Override
+    public void putAll(Map<? extends String, ? extends String> m) {
+        m.forEach(jedis::set);
+    }
+
+    @Override
+    public void clear() {
+        jedis.flushDB();
+    }
+
+    @Override
+    public Set<String> keySet() {
+        return jedis.keys("*");
+    }
+
+    @Override
+    public Collection<String> values() {
+
+        String cursor = "0";
+        List<String> values = new ArrayList<>();
+
+        do {
+            ScanResult<String> scanResult = jedis.scan(cursor);
+            List<String> keys = scanResult.getResult();
+
+            for (String key : keys) {
+                String value = jedis.get(key);
+                values.add(value);
+            }
+
+            cursor = scanResult.getCursor();
+        } while (!"0".equals(cursor));
+
+        return values;
+    }
+
+    @Override
+    public Set<Entry<String, String>> entrySet() {
+
+        String cursor = "0";
+        Set<Entry<String, String>> values = new HashSet<>();
+
+        do {
+            ScanResult<String> scanResult = jedis.scan(cursor);
+            List<String> keys = scanResult.getResult();
+
+            for (String key : keys) {
+                String value = jedis.get(key);
+                values.add(Map.entry(key, value));
+            }
+
+            cursor = scanResult.getCursor();
+        } while (!"0".equals(cursor));
+
+        return values;
+    }
+
+
+}

src/test/java/org/redis/map/RedisMapTest.java

@@ -0,0 +1,147 @@
+package org.redis.map;
+
+import org.junit.jupiter.api.*;
+import redis.clients.jedis.Jedis;
+
+import java.util.*;
+
+import static org.junit.jupiter.api.Assertions.*;
+
+@TestInstance(TestInstance.Lifecycle.PER_CLASS)
+class RedisMapTest {
+
+    private Jedis jedis;
+    private RedisMap redisMap;
+
+    @BeforeAll
+    void setUpAll() {
+        jedis = new Jedis("localhost", 6379);
+    }
+
+    /**
+     * for clearing db
+     */
+    @BeforeEach
+    void setUp() {
+        jedis.flushDB();
+        redisMap = new RedisMap(jedis);
+    }
+
+    @AfterAll
+    void tearDownAll() {
+        jedis.close();
+    }
+
+    @Test
+    void testPutAndGet() {
+        redisMap.put("k1", "v1");
+        assertEquals("v1", redisMap.get("k1"));
+    }
+
+    @Test
+    void testPutReturnsOldValue() {
+        redisMap.put("k1", "v1");
+        String old = redisMap.put("k1", "v2");
+        assertEquals("v1", old);
+        assertEquals("v2", redisMap.get("k1"));
+    }
+
+    @Test
+    void testContainsKey() {
+        redisMap.put("name", "name1");
+        assertTrue(redisMap.containsKey("name"));
+        assertFalse(redisMap.containsKey("noname"));
+    }
+
+    @Test
+    void testContainsValue() {
+        redisMap.put("first", "firstValue");
+        assertTrue(redisMap.containsValue("firstValue"));
+        assertFalse(redisMap.containsValue("secondValue"));
+    }
+
+    @Test
+    void testRemove() {
+        redisMap.put("temp", "123");
+        String oldValue = redisMap.remove("temp");
+        assertEquals("123", oldValue);
+        assertFalse(redisMap.containsKey("temp"));
+    }
+
+    @Test
+    void testPutAll() {
+        Map<String, String> bulk = Map.of("a", "1", "b", "2");
+        redisMap.putAll(bulk);
+        assertEquals(2, redisMap.size());
+        assertEquals("1", redisMap.get("a"));
+    }
+
+    @Test
+    void testClear() {
+        redisMap.put("x", "1");
+        redisMap.put("y", "2");
+        redisMap.clear();
+        assertEquals(0, redisMap.size());
+    }
+
+    @Test
+    void testKeySet() {
+        redisMap.put("k1", "v1");
+        redisMap.put("k2", "v2");
+        Set<String> keys = redisMap.keySet();
+        assertTrue(keys.containsAll(List.of("k1", "k2")));
+    }
+
+    @Test
+    void testValues() {
+        redisMap.put("k1", "v1");
+        redisMap.put("k2", "v2");
+        Collection<String> values = redisMap.values();
+        assertTrue(values.containsAll(List.of("v1", "v2")));
+    }
+
+    @Test
+    void testEntrySet() {
+        redisMap.put("k1", "v1");
+        redisMap.put("k2", "v2");
+        Set<Map.Entry<String, String>> entries = redisMap.entrySet();
+        assertTrue(entries.contains(Map.entry("k1", "v1")));
+        assertTrue(entries.contains(Map.entry("k2", "v2")));
+    }
+
+    @Test
+    void testIsEmptyAndSize() {
+        assertTrue(redisMap.isEmpty());
+        redisMap.put("key", "val");
+        assertEquals(1, redisMap.size());
+        assertFalse(redisMap.isEmpty());
+    }
+
+    @Test
+    void testBasicOperations() {
+        RedisMap map = new RedisMap(jedis);
+
+        // Put and Get
+        map.put("key1", "value1");
+        assertEquals("value1", map.get("key1"));
+
+        // Remove
+        map.remove("key1");
+        assertNull(map.get("key1"));
+
+        // Size
+        map.put("key1", "value1");
+        map.put("key2", "value2");
+        assertEquals(2, map.size());
+
+        // ContainsKey
+        assertTrue(map.containsKey("key1"));
+        assertFalse(map.containsKey("key3"));
+
+        // Clear
+        map.clear();
+        assertTrue(map.isEmpty());
+    }
+
+}
+