BF.Insert + Tests

Author: shacharPash

src/NRedisStack.Core/Bloom/BloomCommands.cs

@@ -16,29 +16,66 @@ public RedisResult Add(RedisKey key, string item)
             return _db.Execute(BF.ADD, key, item);
         }
 
-        public RedisResult Exists(RedisKey key, string item)
+        public bool Exists(RedisKey key, string item)
         {
-            return _db.Execute(BF.EXISTS, key, item);
+            return _db.Execute(BF.EXISTS, key, item).ToString() == "1";
         }
 
         public RedisResult Info(RedisKey key)
         {
             return _db.Execute(BF.INFO, key);
         }
 
-        public RedisResult Insert(RedisKey key)
+        public RedisResult Insert(RedisKey key, RedisValue[] items, int? capacity = null,
+                                  double? error = null, int? expansion = null,
+                                  bool nocreate = false, bool nonscaling = false) //NOT DONE
         {
-            return _db.Execute(BF.INFO, key);
+            if (items == null)
+                throw new ArgumentNullException(nameof(items));
+
+            List<object> args = new List<object> { key };
+
+            if (capacity != null)
+            {
+                args.Add(BloomArgs.CAPACITY);
+                args.Add(capacity);
+            }
+
+            if (error != null)
+            {
+                args.Add(BloomArgs.ERROR);
+                args.Add(error);
+            }
+
+            if (expansion != null)
+            {
+                args.Add(BloomArgs.EXPANSION);
+                args.Add(expansion);
+            }
+
+            if (nocreate)
+                args.Add(BloomArgs.NOCREATE);
+
+            if (nonscaling)
+                args.Add(BloomArgs.NONSCALING);
+
+            args.Add(BloomArgs.ITEMS);
+            foreach (var item in items)
+            {
+                args.Add(item);
+            }
+
+            return _db.Execute(BF.INSERT, args);
         }
 
         public RedisResult ScanDump(RedisKey key, int iterator)
         {
             return _db.Execute(BF.SCANDUMP, key, iterator);
         }
 
-        public RedisResult LoadChunk(RedisKey key, int iterator, string data)
+        public RedisResult LoadChunk(RedisKey key, int iterator, RedisValue data)
         {
-            return _db.Execute(BF.INFO, key, iterator, data);
+            return _db.Execute(BF.LOADCHUNK, key, iterator, data);
         }
 
     }

src/NRedisStack.Core/Bloom/Literals/CommandArgs.cs

@@ -2,6 +2,12 @@ namespace NRedisStack.Core.Literals
 {
     internal class BloomArgs
     {
+        public static string CAPACITY => "CAPACITY";
+        public static string ERROR => "ERROR";
+        public static string EXPANSION => "EXPANSION";
+        public static string NOCREATE => "NOCREATE";
+        public static string NONSCALING => "NONSCALING";
+        public static string ITEMS => "ITEMS";
 
     }
 }

src/NRedisStack.Core/Json/JsonCommands.cs

@@ -16,13 +16,13 @@ public JsonCommands(IDatabase db)
     {
         DefaultIgnoreCondition = JsonIgnoreCondition.WhenWritingNull,
     };
-    public RedisResult Set(RedisKey key, string path, object obj, When when = When.Always)
+    public RedisResult Set(RedisKey key, RedisValue path, object obj, When when = When.Always)
     {
         string json = JsonSerializer.Serialize(obj);
         return Set(key, path, json, when);
     }
 
-    public RedisResult Set(RedisKey key, string path, string json, When when = When.Always)
+    public RedisResult Set(RedisKey key, RedisValue path, RedisValue json, When when = When.Always)
     {
         switch (when)
         {
@@ -35,33 +35,34 @@ public RedisResult Set(RedisKey key, string path, string json, When when = When.
         }
     }
 
-    public RedisResult Get(RedisKey key, string indent = "",
-                                      string newLine = "", string space = "", string path = "")
+    public RedisResult Get(RedisKey key, RedisValue? indent = null,
+                                      RedisValue? newLine = null, RedisValue? space = null, RedisValue? path = null)
     {
-        List<object> subcommands = new List<object>();
-        subcommands.Add(key);
-        if (indent != "")
+        List<object> args = new List<object>();
+        args.Add(key);
+        if (indent != null)
         {
-            subcommands.Add(JsonArgs.INDENT);
-            subcommands.Add(indent);
+            args.Add(JsonArgs.INDENT);
+            args.Add(indent);
         }
 
-        if (newLine != "")
+        if (newLine != null)
         {
-            subcommands.Add(JsonArgs.NEWLINE);
-            subcommands.Add(newLine);
+            args.Add(JsonArgs.NEWLINE);
+            args.Add(newLine);
         }
 
-        if (space != "")
+        if (space != null)
         {
-            subcommands.Add(JsonArgs.SPACE);
-            subcommands.Add(space);
+            args.Add(JsonArgs.SPACE);
+            args.Add(space);
         }
 
-        if (path != "")
+        if (path != null)
         {
-            subcommands.Add(path);
+            args.Add(path);
         }
-        return _db.Execute(JSON.GET, subcommands.ToArray());
+
+        return _db.Execute(JSON.GET, args);
     }
 }

src/NRedisStack.Core/Search/SearchCommands.cs

@@ -9,7 +9,7 @@ public SearchCommands(IDatabase db)
         {
             _db = db;
         }
-        public RedisResult Info(string index)
+        public RedisResult Info(RedisValue index)
         {
             return _db.Execute(FT.INFO, index);
         }

tests/NRedisStack.Tests/Bloom/BloomTests.cs

@@ -32,6 +32,19 @@ public void TestBfAddExists()
         IDatabase db = redisFixture.Redis.GetDatabase();
 
         db.BF().Add(key, "item1");
-        Assert.True(db.BF().Exists(key, "item1").ToString() == "1");
+        Assert.True(db.BF().Exists(key, "item1"));
+    }
+
+    [Fact]
+    public void TestBfInsert()
+    {
+        IDatabase db = redisFixture.Redis.GetDatabase();
+        RedisValue[] items = new RedisValue[] { "item1" , "item2", "item3"};
+
+        db.BF().Insert("key", items);
+
+        Assert.True(db.BF().Exists("key", "item1"));
+        Assert.True(db.BF().Exists("key", "item2"));
+        Assert.True(db.BF().Exists("key", "item3"));
     }
 }