test:Dragonfly

.github/workflows/test-dragonfly.yml

@@ -3,7 +3,9 @@ name: Test Dragonfly
 
 on:
   workflow_dispatch:
-
+  pull_request:
+    branches:
+      - master
 
 concurrency:
   group: dragon-fly-${{ github.workflow }}-${{ github.ref }}
@@ -19,13 +21,9 @@ jobs:
           - "test_json"
           - "test_mixins"
           - "test_stack"
-          - "test_connection.py"
+          - "test_hypothesis"
           - "test_asyncredis.py"
-          - "test_general.py"
-          - "test_scan.py"
-          - "test_zadd.py"
           - "test_translations.py"
-          - "test_sortedset_commands.py"
     permissions:
       pull-requests: write
     services:
@@ -43,6 +41,8 @@ jobs:
       - uses: actions/checkout@v6
         with:
           persist-credentials: false
+      - name: Install uv
+        uses: astral-sh/setup-uv@v6
       - uses: actions/setup-python@v6
         with:
           cache-dependency-path: uv.lock
@@ -51,7 +51,7 @@ jobs:
         env:
           PYTHON_KEYRING_BACKEND: keyring.backends.null.Keyring
         run: |
-          uv sync --extra json --extra bf --extra lua --extra cf
+          uv sync --all-extras
 
       - name: Test without coverage
         run: |

.github/workflows/test.yml

@@ -5,9 +5,9 @@ on:
   push:
     branches:
       - master
-  pull_request:
-    branches:
-      - master
+#  pull_request:
+#    branches:
+#      - master
 
 concurrency:
   group: ${{ github.workflow }}-${{ github.ref }}

fakeredis/commands_mixins/bitmap_mixin.py

@@ -231,10 +231,12 @@ def _bitfield_set(
         return new_value if value is None else ans
 
     @command(fixed=(Key(bytes),), repeat=(bytes,))
-    def bitfield(self, key: CommandItem, *args: bytes) -> List[Optional[int]]:
+    def bitfield(self, key: CommandItem, *args: bytes) -> Optional[List[Optional[int]]]:
         overflow = b"WRAP"
         results: List[Optional[int]] = []
         i = 0
+        if len(args) == 0 and self._server.server_type == "dragonfly":
+            raise SimpleError(msgs.WRONG_ARGS_MSG6.format("bitfield"))
         while i < len(args):
             if casematch(args[i], b"overflow") and i + 1 < len(args):
                 overflow = args[i + 1].upper()
@@ -269,4 +271,6 @@ def bitfield(self, key: CommandItem, *args: bytes) -> List[Optional[int]]:
             else:
                 raise SimpleError(msgs.SYNTAX_ERROR_MSG)
 
+        if len(results) == 0 and self._server.server_type == "dragonfly":
+            return None
         return results

fakeredis/stack/_json_mixin.py

@@ -15,6 +15,7 @@
 from fakeredis._commands import Key, command, delete_keys, CommandItem, Int, Float
 from fakeredis._helpers import SimpleString
 from fakeredis.model import ZSet, ClientInfo
+from fakeredis.typing import ServerType
 
 JsonType = Union[str, int, float, bool, None, Dict[str, Any], List[Any]]
 
@@ -169,6 +170,7 @@ def __init__(self, *args: Any, **kwargs: Any) -> None:
         super().__init__(*args, **kwargs)
         self._db: helpers.Database
         self._client_info: ClientInfo
+        self.server_type: ServerType
 
     @staticmethod
     def _get_single(
@@ -465,6 +467,9 @@ def check_index(value: JsonType) -> Optional[int]:
 
     @command(name="JSON.STRLEN", fixed=(Key(),), repeat=(bytes,))
     def json_strlen(self, key: CommandItem, *args: bytes) -> Union[List[Optional[int]], Optional[int]]:
+        if key.value is None:
+            msg = msgs.JSON_KEY_NOT_FOUND if self.server_type != "dragonfly" else msgs.NO_KEY_MSG
+            raise helpers.SimpleError(msg)
         return _json_read_iterate(lambda val: len(val) if type(val) is str else None, key, *args)
 
     @command(name="JSON.ARRLEN", fixed=(Key(),), repeat=(bytes,))

test/test_hypothesis/base.py

@@ -326,6 +326,7 @@ class BaseTest:
 
     command_strategy: SearchStrategy
     create_command_strategy = st.nothing()
+    command_strategy_dragonfly = st.nothing()
     command_strategy_redis7 = st.nothing()
     command_strategy_redis_only = st.nothing()
 
@@ -334,6 +335,8 @@ def test(self):
         class Machine(CommonMachine):
             create_command_strategy = self.create_command_strategy
             command_strategy = self.command_strategy
+            if server_type == "dragonfly":
+                command_strategy = command_strategy | self.command_strategy_dragonfly
             if server_type == "redis":
                 command_strategy = command_strategy | self.command_strategy_redis_only
             if server_type == "redis" and redis_ver >= (7,):

test/test_hypothesis/test_hash.py

@@ -41,6 +41,9 @@ class TestHash(BaseTest):
             st.lists(fields, min_size=2, max_size=2, unique=True),
         )
     )
+    command_strategy_dragonfly = commands(
+        st.just("hexpiretime"), st.just("fields"), st.just(2), st.lists(fields, min_size=2, max_size=2)
+    ) | commands(st.just("hpexpiretime"), st.just("fields"), st.just(2), st.lists(fields, min_size=2, max_size=2))
     command_strategy_redis7 = (
         commands(st.just("hpersist"), st.just("fields"), st.just(2), st.lists(fields, min_size=2, max_size=2))
         | commands(st.just("hexpiretime"), st.just("fields"), st.just(2), st.lists(fields, min_size=2, max_size=2))

test/test_hypothesis/test_server.py

@@ -1,4 +1,11 @@
-from .base import BaseTest, commands, st, common_commands, keys, values
+from .base import (
+    BaseTest,
+    commands,
+    values,
+    st,
+    keys,
+    common_commands,
+)
 from .test_string import string_commands
 
 
@@ -7,11 +14,11 @@ class TestServer(BaseTest):
     #  Find a better way to test this. commands(st.just('bgsave'))
     server_commands = (
         commands(st.just("dbsize"))
-        | commands(st.sampled_from(["flushdb", "flushall"]))
         # TODO: result is non-deterministic
         # | commands(st.just('lastsave'))
         | commands(st.just("save"))
     )
-    command_strategy_redis_only = commands(st.sampled_from(["flushdb", "flushall"]), st.sampled_from([[], "async"]))
+    command_strategy_dragonfly = commands(st.sampled_from(["flushdb", "flushall"]))
+    command_strategy_redis7 = commands(st.sampled_from(["flushdb", "flushall"]), st.sampled_from([[], "async"]))
     create_command_strategy = commands(st.just("set"), keys, values)
     command_strategy = server_commands | string_commands | common_commands

test/test_json/test_json.py

@@ -368,65 +368,25 @@ def test_strappend(r: redis.Redis):
     assert "foobar" == r.json().get("json-key", Path.root_path())
 
     # Test multi
-    r.json().set(
-        "doc1",
-        Path.root_path(),
-        {
-            "a": "foo",
-            "nested1": {"a": "hello"},
-            "nested2": {"a": 31},
-        },
-    )
+    r.json().set("doc1", Path.root_path(), {"a": "foo", "nested1": {"a": "hello"}, "nested2": {"a": 31}})
     assert r.json().strappend("doc1", "bar", "$..a") == [6, 8, None]
-    assert r.json().get("doc1") == {
-        "a": "foobar",
-        "nested1": {"a": "hellobar"},
-        "nested2": {"a": 31},
-    }
+    assert r.json().get("doc1") == {"a": "foobar", "nested1": {"a": "hellobar"}, "nested2": {"a": 31}}
 
     # Test single
-    assert r.json().strappend(
-        "doc1",
-        "baz",
-        "$.nested1.a",
-    ) == [11]
-    assert r.json().get("doc1") == {
-        "a": "foobar",
-        "nested1": {"a": "hellobarbaz"},
-        "nested2": {"a": 31},
-    }
+    assert r.json().strappend("doc1", "baz", "$.nested1.a") == [11]
+    assert r.json().get("doc1") == {"a": "foobar", "nested1": {"a": "hellobarbaz"}, "nested2": {"a": 31}}
 
     # Test missing key
     with pytest.raises(redis.exceptions.ResponseError):
         r.json().strappend("non_existing_doc", "$..a", "err")
 
     # Test multi
-    r.json().set(
-        "doc2",
-        Path.root_path(),
-        {
-            "a": "foo",
-            "nested1": {"a": "hello"},
-            "nested2": {"a": "hi"},
-        },
-    )
+    r.json().set("doc2", Path.root_path(), {"a": "foo", "nested1": {"a": "hello"}, "nested2": {"a": "hi"}})
     assert r.json().strappend("doc2", "bar", "$.*.a") == [8, 5]
-    assert r.json().get("doc2") == {
-        "a": "foo",
-        "nested1": {"a": "hellobar"},
-        "nested2": {"a": "hibar"},
-    }
+    assert r.json().get("doc2") == {"a": "foo", "nested1": {"a": "hellobar"}, "nested2": {"a": "hibar"}}
 
     # Test missing path
-    r.json().set(
-        "doc1",
-        Path.root_path(),
-        {
-            "a": "foo",
-            "nested1": {"a": "hello"},
-            "nested2": {"a": 31},
-        },
-    )
+    r.json().set("doc1", Path.root_path(), {"a": "foo", "nested1": {"a": "hello"}, "nested2": {"a": 31}})
     with pytest.raises(redis.exceptions.ResponseError):
         r.json().strappend("doc1", "add", "piu")
 
@@ -606,15 +566,7 @@ def test_objkeys(r: redis.Redis):
 
     assert r.json().objkeys("fakekey") is None
 
-    r.json().set(
-        "doc1",
-        "$",
-        {
-            "nested1": {"a": {"foo": 10, "bar": 20}},
-            "a": ["foo"],
-            "nested2": {"a": {"baz": 50}},
-        },
-    )
+    r.json().set("doc1", "$", {"nested1": {"a": {"foo": 10, "bar": 20}}, "a": ["foo"], "nested2": {"a": {"baz": 50}}})
 
     # Test single
     keys = r.json().objkeys("doc1", "$.nested1.a")