fakeredis 0.8.0 → 0.9.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c0b77a04c1c761edb3a6544aca213f373d57bb485d17f9e7e0f2c63bfd7e660
-  data.tar.gz: 57975993a6664bc469ee297a6a36d75ac2e4e429972aee6e50a2f518f93ca580
+  metadata.gz: 8f5bfa00feb72f7ffcaa7a1b0c2f316fe6f0e83c1a1e5d68f09f6243aeadca14
+  data.tar.gz: 8c31af643286808f7226f138278673d4523d9ef2fdf39a67336519d762ea9385
 SHA512:
-  metadata.gz: ba35de9b7e297eca69cb7652d7817f257c447d7533d8c259c47215b15355ec49e5c2584907f0726f97327c443de122bd240cbca6fa194222f114bc99ffd0dbb9
-  data.tar.gz: 8c4e340be842d1fe966a3a4c6f63987bc8af346da74ced914cdc77488e08a6d15101ee6625097337287ec55c19f41118da4a79892b7fdd00bbebff1d103a813a
+  metadata.gz: 5164767bdeed993d36fdaf7410c8a79d933b1e3d3958437e5346b080c5ac1c3f78b0f0a4ba77f9438a84f5480cd9f1629aead81e58c1bb9999a258009a944eff
+  data.tar.gz: d337bec1b6a2d54dfa96686cc177ce3c15b660205f8d5c71f7e0b52bee9a40909642604dd70b975755ede946091bc55fec82d644c82df02f2305e0e2d27e630b

data/.github/workflows/codeql.yml

@@ -0,0 +1,74 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ "master" ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ "master" ]
+  schedule:
+    - cron: '34 3 * * 3'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+    permissions:
+      actions: read
+      contents: read
+      security-events: write
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'ruby' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python', 'ruby' ]
+        # Learn more about CodeQL language support at https://aka.ms/codeql-docs/language-support
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v3
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v2
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+
+        # Details on CodeQL's query packs refer to : https://docs.github.com/en/code-security/code-scanning/automatically-scanning-your-code-for-vulnerabilities-and-errors/configuring-code-scanning#using-queries-in-ql-packs
+        # queries: security-extended,security-and-quality
+
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, Go, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v2
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 See https://docs.github.com/en/actions/using-workflows/workflow-syntax-for-github-actions#jobsjob_idstepsrun
+
+    #   If the Autobuild fails above, remove it and uncomment the following three lines.
+    #   modify them (or add more) to build your code if your project, please refer to the EXAMPLE below for guidance.
+
+    # - run: |
+    #   echo "Run, Build Application using script"
+    #   ./location_of_script_within_repo/buildscript.sh
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v2
+      with:
+        category: "/language:${{matrix.language}}"

data/.github/workflows/ruby.yml

@@ -0,0 +1,33 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+# GitHub recommends pinning actions to a commit SHA.
+# To get a newer version, you will need to update the SHA.
+# You can also reference a tag or branch, but the action may change without warning.
+
+name: Ruby CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    runs-on: ${{ matrix.os }}-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu, macos]
+        ruby: [2.7, 3.0, 3.1, 3.2, head, debug, jruby, jruby-head, truffleruby, truffleruby-head]
+    continue-on-error: ${{ endsWith(matrix.ruby, 'head') || matrix.ruby == 'debug' }}
+    steps:
+      - uses: actions/checkout@v3
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: ${{ matrix.ruby }}
+      - run: bundle install
+      - run: bundle exec rake

data/Gemfile

@@ -3,11 +3,5 @@ source "https://rubygems.org"
 gem 'rake'
 gem 'rdoc'
 
-platforms :rbx do
-  gem 'racc'
-  gem 'rubysl', '~> 2.0'
-  gem 'psych'
-end
-
 # Specify your gem's dependencies in fakeredis.gemspec
 gemspec

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2011-2018 Guillermo Iguaran
+Copyright (c) 2011-2023 Guillermo Iguaran
 
 Permission is hereby granted, free of charge, to any person obtaining
 a copy of this software and associated documentation files (the

data/README.md

@@ -1,4 +1,6 @@
-# FakeRedis [![Build Status](https://secure.travis-ci.org/guilleiguaran/fakeredis.png)](http://travis-ci.org/guilleiguaran/fakeredis)
+# FakeRedis
+![Build Status](https://github.com/guilleiguaran/fakeredis/actions/workflows/ruby.yml/badge.svg)
+
 This a fake implementation of redis-rb for machines without Redis or test environments
 
 
@@ -85,7 +87,7 @@ require 'fakeredis/minitest'
 
 ## Acknowledgements
 
-Thanks to [all contributors](https://github.com/guilleiguaran/fakeredis/graphs/contributors), specially to [Caius Durling](https://github.com/caius) the most active one.
+Thanks to [all contributors](https://github.com/guilleiguaran/fakeredis/graphs/contributors).
 
 ## Contributing to FakeRedis
 
@@ -100,5 +102,4 @@ Thanks to [all contributors](https://github.com/guilleiguaran/fakeredis/graphs/c
 
 ## Copyright
 
-Copyright (c) 2011-2018 Guillermo Iguaran. See LICENSE for
-further details.
+Copyright (c) 2011-2023 Guillermo Iguaran. See LICENSE for further details.

data/fakeredis.gemspec

@@ -18,6 +18,6 @@ Gem::Specification.new do |s|
   s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
   s.require_paths = ["lib"]
 
-  s.add_runtime_dependency(%q<redis>, ["~> 4.1"])
-  s.add_development_dependency(%q<rspec>, ["~> 3.0"])
+  s.add_runtime_dependency(%q<redis>, ["~> 4.8"])
+  s.add_development_dependency(%q<rspec>, ["~> 3"])
 end

data/lib/fakeredis/geo_commands.rb

@@ -74,7 +74,7 @@ module FakeRedis
     def georadiusbymember(*args)
       args = args.dup
       raise_argument_error("georadiusbymember") if args.size < 4
-      key, member, radius, unit, *rest = args
+      key, member, radius, unit, *_ = args
       raise_argument_error("georadiusbymember") unless DISTANCE_UNITS.has_key?(unit)
       radius *= DISTANCE_UNITS[unit]
 

data/lib/fakeredis/version.rb

@@ -1,3 +1,3 @@
 module FakeRedis
-  VERSION = "0.8.0"
+  VERSION = "0.9.1"
 end

data/lib/fakeredis/zset.rb

@@ -26,7 +26,7 @@ module FakeRedis
     def _floatify(str, increment = true)
       if (( inf = str.to_s.match(/^([+-])?inf/i) ))
         (inf[1] == "-" ? -1.0 : 1.0) / 0.0
-      elsif (( number = str.to_s.match(/^\((\d+)/i) ))
+      elsif (( number = str.to_s.match(/^\((-?\d+)/i) ))
         number[1].to_i + (increment ? 1 : -1)
       else
         Float str.to_s

data/lib/redis/connection/memory.rb

@@ -86,13 +86,14 @@ class Redis
       attr_writer :replies
 
       def connected?
-        true
+        defined?(@disconnected) ? false : true
       end
 
       def connect_unix(path, timeout)
       end
 
       def disconnect
+        @disconnected = true
       end
 
       def client(command, _options = {})
@@ -121,7 +122,7 @@ class Redis
         "OK"
       end
 
-      def auth(password)
+      def auth(*args)
         "OK"
       end
 
@@ -168,7 +169,7 @@ class Redis
       end
 
       def dump(key)
-        return nil unless exists(key)
+        return nil if exists(key).zero?
 
         value = data[key]
 
@@ -179,7 +180,7 @@ class Redis
       end
 
       def restore(key, ttl, serialized_value)
-        raise Redis::CommandError, "ERR Target key name is busy." if exists(key)
+        raise Redis::CommandError, "ERR Target key name is busy." if exists(key) > 0
 
         raise Redis::CommandError, "ERR DUMP payload version or checksum are wrong" if serialized_value.nil?
 
@@ -240,9 +241,9 @@ class Redis
       end
 
       def mget(*keys)
+        keys = keys[0] if flatten?(keys)
         raise_argument_error('mget') if keys.empty?
-        # We work with either an array, or list of arguments
-        keys = keys.first if keys.size == 1
+        keys.each { |key| data_type_check(key, String) }
         data.values_at(*keys)
       end
 
@@ -358,7 +359,11 @@ class Redis
         data.keys.count
       end
 
-      def exists(key)
+      def exists(*keys)
+        keys.count { |key| data.key?(key) }
+      end
+
+      def exists?(key)
         data.key?(key)
       end
 
@@ -542,6 +547,8 @@ class Redis
 
       def sadd(key, value)
         data_type_check(key, ::Set)
+        should_return_int = value.is_a? Array
+
         value = Array(value)
         raise_argument_error('sadd') if value.empty?
 
@@ -554,15 +561,21 @@ class Redis
           data[key].size
         end
 
-        # 0 = false, 1 = true, 2+ untouched
-        return result == 1 if result < 2
+        # 0 = false, 1 = true unless an array was passed in
+        if Redis.sadd_returns_boolean && !should_return_int
+          return result == 1
+        end
+
         result
       end
 
+      def sadd?(key, value)
+        sadd(key, value) == 1
+      end
+
       def srem(key, value)
         data_type_check(key, ::Set)
-        value = Array(value)
-        raise_argument_error('srem') if value.empty?
+        raise_argument_error('srem') if Array(value).empty?
         return false unless data[key]
 
         if value.is_a?(Array)
@@ -649,6 +662,8 @@ class Redis
         data_type_check(destination, ::Set)
         result = sdiff(key1, *keys)
         data[destination] = ::Set.new(result)
+
+        result.size
       end
 
       def srandmember(key, number=nil)
@@ -702,7 +717,7 @@ class Redis
       end
 
       def setnx(key, value)
-        if exists(key)
+        if exists(key) > 0
           0
         else
           set(key, value)
@@ -718,7 +733,7 @@ class Redis
       end
 
       def renamenx(key, new_key)
-        if exists(new_key)
+        if exists(new_key) > 0
           false
         else
           rename(key, new_key)
@@ -742,7 +757,7 @@ class Redis
         if data.expires.include?(key) && (ttl = data.expires[key].to_i - Time.now.to_i) > 0
           ttl
         else
-          exists(key) ? -1 : -2
+          exists(key) > 0 ? -1 : -2
         end
       end
 
@@ -750,7 +765,7 @@ class Redis
         if data.expires.include?(key) && (ttl = data.expires[key].to_f - Time.now.to_f) > 0
           ttl * 1000
         else
-          exists(key) ? -1 : -2
+          exists(key) > 0 ? -1 : -2
         end
       end
 
@@ -763,17 +778,32 @@ class Redis
         !!data.expires.delete(key)
       end
 
-      def hset(key, field, value)
+      def hset(key, *fields)
+        fields = fields.first if fields.size == 1 && fields.first.is_a?(Hash)
+        raise_argument_error('hset') if fields.empty?
+
+        is_list_of_arrays = fields.all?{|field| field.instance_of?(Array)}
+
+        raise_argument_error('hmset') if fields.size.odd? and !is_list_of_arrays
+        raise_argument_error('hmset') if is_list_of_arrays and !fields.all?{|field| field.length == 2}
+
         data_type_check(key, Hash)
-        field = field.to_s
-        if data[key]
-          result = !data[key].include?(field)
-          data[key][field] = value.to_s
-          result ? 1 : 0
+        insert_count = 0
+        data[key] ||= {}
+
+        if fields.is_a?(Hash)
+          insert_count = fields.keys.size - (data[key].keys & fields.keys).size
+
+          data[key].merge!(fields)
         else
-          data[key] = { field => value.to_s }
-          1
+          fields.each_slice(2) do |field|
+            insert_count += 1 if data[key][field[0].to_s].nil?
+
+            data[key][field[0].to_s] = field[1].to_s
+          end
         end
+
+        insert_count
       end
 
       def hsetnx(key, field, value)
@@ -876,12 +906,13 @@ class Redis
 
         return nil if option_nx && option_xx
 
-        return nil if option_nx && exists(key)
-        return nil if option_xx && !exists(key)
+        return nil if option_nx && exists(key) > 0
+        return nil if option_xx && exists(key).zero?
 
         data[key] = value.to_s
 
         options = Hash[array_options.each_slice(2).to_a]
+        raise_command_error('ERR value is not an integer or out of range') if non_integer_expirations?(options)
         ttl_in_seconds = options["EX"] if options["EX"]
         ttl_in_seconds = options["PX"] / 1000.0 if options["PX"]
 
@@ -890,6 +921,11 @@ class Redis
         "OK"
       end
 
+      def non_integer_expirations?(options)
+        (options["EX"] && !options["EX"].is_a?(Integer)) ||
+          (options["PX"] && !options["PX"].is_a?(Integer))
+      end
+
       def setbit(key, offset, bit)
         old_val = data[key] ? data[key].unpack('B*')[0].split("") : []
         size_increment = [((offset/8)+1)*8-old_val.length, 0].max
@@ -903,13 +939,17 @@ class Redis
       end
 
       def setex(key, seconds, value)
+        raise_command_error('ERR value is not an integer or out of range') unless seconds.is_a?(Integer)
         data[key] = value.to_s
         expire(key, seconds)
         "OK"
       end
 
       def psetex(key, milliseconds, value)
-        setex(key, milliseconds / 1000.0, value)
+        raise_command_error('ERR value is not an integer or out of range') unless milliseconds.is_a?(Integer)
+        data[key] = value.to_s
+        expire(key, milliseconds / 1000.0)
+        "OK"
       end
 
       def setrange(key, offset, value)
@@ -1116,12 +1156,12 @@ class Redis
         count.nil? ? results.first : results.flatten
       end
 
-      def bzpopmax(*args)
-        bzpop(:bzpopmax, args)
+      def bzpopmax(*args, timeout: 0)
+        bzpop(:bzpopmax, args, timeout)
       end
 
-      def bzpopmin(*args)
-        bzpop(:bzpopmin, args)
+      def bzpopmin(*args, timeout: 0)
+        bzpop(:bzpopmin, args, timeout)
       end
 
       def zcard(key)
@@ -1153,7 +1193,7 @@ class Redis
         data[key][value.to_s] ||= 0
         data[key].increment(value.to_s, num)
 
-        if num =~ /^\+?inf/
+        if num.is_a?(String) && num =~ /^\+?inf/
           "inf"
         elsif num == "-inf"
           "-inf"
@@ -1560,15 +1600,7 @@ class Redis
           end
         end
 
-        def bzpop(command, args)
-          timeout =
-            if args.last.is_a?(Hash)
-              args.pop[:timeout]
-            elsif args.last.respond_to?(:to_int)
-              args.pop.to_int
-            end
-
-          timeout ||= 0
+        def bzpop(command, args, timeout)
           single_pop_command = command.to_s[1..-1]
           keys = args.flatten
           keys.each do |key|

data/spec/hashes_spec.rb

@@ -32,7 +32,7 @@ module FakeRedis
       expect(@client.hdel("key1", "k1")).to be(1)
       expect(@client.hdel("key1", "k2")).to be(1)
 
-      expect(@client.exists("key1")).to eq(false)
+      expect(@client.exists("key1")).to eq(0)
     end
 
     it "should convert key to a string for hset" do
@@ -135,13 +135,13 @@ module FakeRedis
 
     it "should reject an empty list of values" do
       expect { @client.hmset("key") }.to raise_error(Redis::CommandError)
-      expect(@client.exists("key")).to be false
+      expect(@client.exists?("key")).to be false
     end
 
     it "rejects an insert with a key but no value" do
       expect { @client.hmset("key", 'foo') }.to raise_error(Redis::CommandError)
       expect { @client.hmset("key", 'foo', 3, 'bar') }.to raise_error(Redis::CommandError)
-      expect(@client.exists("key")).to be false
+      expect(@client.exists?("key")).to be false
     end
 
     it "should reject the wrong number of arguments" do
@@ -167,12 +167,42 @@ module FakeRedis
     end
 
     it "should set the string value of a hash field" do
-      expect(@client.hset("key1", "k1", "val1")).to eq(true)
-      expect(@client.hset("key1", "k1", "val1")).to eq(false)
+      expect(@client.hset("key1", "k1", "val1")).to eq(1)
+      expect(@client.hset("key1", "k1", "val1")).to eq(0)
 
       expect(@client.hget("key1", "k1")).to eq("val1")
     end
 
+    it "should accept a list of key-value pair" do
+      @client.hset("key1", "k1", "val1", "k2", "val2")
+
+      expect(@client.hget("key1", "k1")).to eq("val1")
+      expect(@client.hget("key1", "k2")).to eq("val2")
+    end
+
+    it "should accept a hash of attributes to insert" do
+      @client.hset("key1", {"k1" => "val1", "k2" => "val2"})
+
+      expect(@client.hget("key1", "k1")).to eq("val1")
+      expect(@client.hget("key1", "k2")).to eq("val2")
+    end
+
+    it "should return correct value when inserting a list of key-value pair" do
+      @client.hset("key1", "k1", "val1", "k2", "val2")
+
+      expect(@client.hset("key1", "k1", "val1", "k2", "val2")).to eq(0)
+      expect(@client.hset("key1", "k2", "val2", "k3", "val3")).to eq(1)
+      expect(@client.hset("key1", "k4", "val4", "k5", "val5")).to eq(2)
+    end
+
+    it "should return correct value when inserting a hash of attributes" do
+      @client.hset("key1", { "k1" => "val1", "k2" => "val2" })
+
+      expect(@client.hset("key1", { "k1" => "val1", "k2" => "val2" })).to eq(0)
+      expect(@client.hset("key1", { "k2" => "val2", "k3" => "val3" })).to eq(1)
+      expect(@client.hset("key1", { "k4" => "val4", "k5" => "val5" })).to eq(2)
+    end
+
     it "should set the value of a hash field, only if the field does not exist" do
       @client.hset("key1", "k1", "val1")
       expect(@client.hsetnx("key1", "k1", "value")).to eq(false)

data/spec/keys_spec.rb

@@ -29,11 +29,16 @@ module FakeRedis
         @client.set("key1", "1")
         expect(@client.public_send(command, ["key1", "key2"])).to eq(1)
       end
+    end
 
-      it "should error '#{command}'ing no keys" do
-        expect { @client.public_send(command) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for '#{command}' command")
-        expect { @client.public_send(command, []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for '#{command}' command")
-      end
+    it "should return 0 when deleting no keys" do
+      expect(@client.del).to eq(0)
+      expect(@client.del([])).to eq(0)
+    end
+
+    it "should error when unlinking no keys" do
+      expect { @client.unlink }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'unlink' command")
+      expect { @client.unlink([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'unlink' command")
     end
 
     it "should return true when setnx keys that don't exist" do
@@ -63,13 +68,6 @@ module FakeRedis
       expect(@client.pexpire("key1", 1)).to eq(false)
     end
 
-    it "should determine if a key exists" do
-      @client.set("key1", "1")
-
-      expect(@client.exists("key1")).to eq(true)
-      expect(@client.exists("key2")).to eq(false)
-    end
-
     it "should set a key's time to live in seconds" do
       @client.set("key1", "1")
       @client.expire("key1", 1)
@@ -134,7 +132,7 @@ module FakeRedis
       @client.set("key1", "1")
       @client.expireat("key1", Time.now.to_i)
 
-      expect(@client.exists("key1")).to be false
+      expect(@client.exists?("key1")).to be false
     end
 
     it "should get integer and string keys" do
@@ -362,14 +360,14 @@ module FakeRedis
       it "uses ex option to set the expire time, in seconds" do
         ttl = 7
 
-        expect(@client.set("key1", "1", { :ex => ttl })).to eq("OK")
+        expect(@client.set("key1", "1", ex: ttl)).to eq("OK")
         expect(@client.ttl("key1")).to eq(ttl)
       end
 
       it "uses px option to set the expire time, in miliseconds" do
         ttl = 7000
 
-        expect(@client.set("key1", "1", { :px => ttl })).to eq("OK")
+        expect(@client.set("key1", "1", px: ttl)).to eq("OK")
         expect(@client.ttl("key1")).to eq(ttl / 1000)
       end
 
@@ -379,37 +377,37 @@ module FakeRedis
         ttl_px = 6000
         ttl_ex = 10
 
-        @client.set("key1", "1", { :px => ttl_px, :ex => ttl_ex })
+        @client.set("key1", "1", px: ttl_px, ex: ttl_ex)
         expect(@client.ttl("key1")).to eq(ttl_px / 1000)
 
-        @client.set("key1", "1", { :ex => ttl_ex, :px => ttl_px })
+        @client.set("key1", "1", ex: ttl_ex, px: ttl_px)
         expect(@client.ttl("key1")).to eq(ttl_px / 1000)
       end
 
       it "uses nx option to only set the key if it does not already exist" do
-        expect(@client.set("key1", "1", { :nx => true })).to eq(true)
-        expect(@client.set("key1", "2", { :nx => true })).to eq(false)
+        expect(@client.set("key1", "1", nx: true)).to eq(true)
+        expect(@client.set("key1", "2", nx: true)).to eq(false)
 
         expect(@client.get("key1")).to eq("1")
       end
 
       it "uses xx option to only set the key if it already exists" do
-        expect(@client.set("key2", "1", { :xx => true })).to eq(false)
+        expect(@client.set("key2", "1", xx: true)).to eq(false)
         @client.set("key2", "2")
-        expect(@client.set("key2", "1", { :xx => true })).to eq(true)
+        expect(@client.set("key2", "1", xx: true)).to eq(true)
 
         expect(@client.get("key2")).to eq("1")
       end
 
       it "does not set the key if both xx and nx option are specified" do
-        expect(@client.set("key2", "1", { :nx => true, :xx => true })).to eq(false)
+        expect(@client.set("key2", "1", nx: true, xx: true)).to eq(false)
         expect(@client.get("key2")).to be_nil
       end
     end
 
     describe "#dump" do
       it "returns nil for unknown key" do
-        expect(@client.exists("key1")).to be false
+        expect(@client.exists?("key1")).to be false
         expect(@client.dump("key1")).to be nil
       end
 
@@ -445,7 +443,7 @@ module FakeRedis
           @dumped_value = @client.dump("key1")
 
           @client.del("key1")
-          expect(@client.exists("key1")).to be false
+          expect(@client.exists?("key1")).to be false
         end
 
         it "restores to a new key successfully" do
@@ -504,10 +502,45 @@ module FakeRedis
         expect(@client.pttl("key")).to be_within(0.1).of(2200)
       end
 
+      it "should raise an error if a non-integer is provided as the expiration" do
+        expect { @client.psetex("key", 100.5, "value") }.to raise_error(Redis::CommandError)
+      end
+
       it "should return 'OK'" do
         expect(@client.psetex("key", 1000, "value")).to eq("OK")
       end
     end
+
+    describe "#exists" do
+      it "returns 0 if none of the keys exist" do
+        expect(@client.exists("key1", "key2")).to eq 0
+      end
+
+      it "returns number of the keys that exist" do
+        @client.set("key2", "val2")
+        @client.set("key3", "val3")
+        expect(@client.exists("key1", "key2", "key3")).to eq 2
+      end
+
+      it "keys mentioned and existing multiple times counted multiple times" do
+        @client.set("key2", "val")
+        expect(@client.exists("key2", "key2")).to eq 2
+      end
+    end
+
+    describe "#exists?" do
+      it "should return true if any of the key exists" do
+        @client.set("key1", "1")
+
+        expect(@client.exists?("key1")).to eq(true)
+        expect(@client.exists?("key1", "key2")).to eq(true)
+      end
+
+      it "should return false if none of the key exists" do
+        expect(@client.exists?("key2")).to eq(false)
+        expect(@client.exists?("key2", "key3")).to eq(false)
+      end
+    end
   end
 end
 

data/spec/lists_spec.rb

@@ -119,7 +119,7 @@ module FakeRedis
     end
 
     it "should return 0 if key does not map to a list" do
-      expect(@client.exists("nonexistant")).to eq(false)
+      expect(@client.exists?("nonexistant")).to eq(false)
       expect(@client.lrem("nonexistant", 0, "value")).to eq(0)
     end
 
@@ -129,7 +129,7 @@ module FakeRedis
       @client.lrem("key1", 1, "v1")
       @client.lrem("key1", 1, "v2")
 
-      expect(@client.exists("key1")).to eq(false)
+      expect(@client.exists?("key1")).to eq(false)
     end
 
     it "should set the value of an element in a list by its index" do

data/spec/memory_spec.rb

@@ -21,7 +21,7 @@ RSpec.describe FakeRedis do
       cursor = 0
 
       loop do
-        cursor, keys = redis.scan(cursor, match_arguments)
+        cursor, keys = redis.scan(cursor, **match_arguments)
         returned_keys += keys
         break if cursor == '0'
       end

data/spec/server_spec.rb

@@ -45,13 +45,13 @@ module FakeRedis
 
         @client.select(0)
         expect(@client.dbsize).to eq(2)
-        expect(@client.exists("key1")).to be true
-        expect(@client.exists("key3")).to be false
+        expect(@client.exists?("key1")).to be true
+        expect(@client.exists?("key3")).to be false
 
         @client.select(1)
         expect(@client.dbsize).to eq(3)
-        expect(@client.exists("key4")).to be true
-        expect(@client.exists("key2")).to be false
+        expect(@client.exists?("key4")).to be true
+        expect(@client.exists?("key2")).to be false
 
         @client.flushall
         expect(@client.dbsize).to eq(0)

data/spec/sets_spec.rb

@@ -7,8 +7,8 @@ module FakeRedis
     end
 
     it "should add a member to a set" do
-      expect(@client.sadd("key", "value")).to eq(true)
-      expect(@client.sadd("key", "value")).to eq(false)
+      expect(@client.sadd?("key", "value")).to eq(true)
+      expect(@client.sadd?("key", "value")).to eq(false)
 
       expect(@client.smembers("key")).to eq(["value"])
     end
@@ -30,6 +30,13 @@ module FakeRedis
       expect(@client.smembers("key")).to match_array(["value", "other", "something", "more", "and", "additional", "values"])
     end
 
+    it "should return the number added to a set when an array is passed in" do
+      expect(@client.sadd("key", %w(value other something more))).to eq(4)
+      expect(@client.sadd("key", %w(more value additional))).to eq(1)
+      expect(@client.sadd("key", %w(additional))).to eq(0)
+      expect(@client.smembers("key")).to match_array(["value", "other", "something", "more", "additional"])
+    end
+
     it "should get the number of members in a set" do
       @client.sadd("key", "val1")
       @client.sadd("key", "val2")
@@ -75,6 +82,19 @@ module FakeRedis
       expect(@client.smembers("new_key")).to match_array(["b", "d"])
     end
 
+    it "should return integer on sdiffstore" do
+      @client.sadd("key1", "a")
+      @client.sadd("key1", "b")
+      @client.sadd("key1", "c")
+      @client.sadd("key1", "d")
+      @client.sadd("key2", "c")
+      @client.sadd("key3", "a")
+      @client.sadd("key3", "c")
+      @client.sadd("key3", "e")
+
+      expect(@client.sdiffstore("key", "key1", "key2", "key3")).to eq(2)
+    end
+
     it "should intersect multiple sets" do
       @client.sadd("key1", "a")
       @client.sadd("key1", "b")
@@ -188,7 +208,7 @@ module FakeRedis
       @client.srem("key1", "b")
       @client.srem("key1", "a")
 
-      expect(@client.exists("key1")).to eq(false)
+      expect(@client.exists?("key1")).to eq(false)
     end
 
     it "should add multiple sets" do

data/spec/sorted_sets_spec.rb

@@ -100,7 +100,7 @@ module FakeRedis
     it "should remove sorted set's key when it is empty" do
       @client.zadd("key", 1, "val")
       @client.zrem("key", "val")
-      expect(@client.exists("key")).to eq(false)
+      expect(@client.exists?("key")).to eq(false)
     end
 
     it "should pop members with the highest scores from sorted set" do
@@ -120,14 +120,14 @@ module FakeRedis
     it "should pop members with the highest score from first sorted set that is non-empty" do
       @client.zadd("key1", [1, "val1", 2, "val2"])
       @client.zadd("key2", [3, "val3"])
-      expect(@client.bzpopmax("nonexistent", "key1", "key2", 0)).to eq(["key1", "val2", 2.0])
+      expect(@client.bzpopmax("nonexistent", "key1", "key2", timeout: 0)).to eq(["key1", "val2", 2.0])
       expect(@client.bzpopmax("nonexistent")).to eq(nil)
     end
 
     it "should pop members with the lowest score from first sorted set that is non-empty" do
       @client.zadd("key1", [1, "val1", 2, "val2"])
       @client.zadd("key2", [3, "val3"])
-      expect(@client.bzpopmin("nonexistent", "key1", "key2", 0)).to eq(["key1", "val1", 1.0])
+      expect(@client.bzpopmin("nonexistent", "key1", "key2", timeout: 0)).to eq(["key1", "val1", 1.0])
       expect(@client.bzpopmin("nonexistent")).to eq(nil)
     end
 
@@ -685,13 +685,13 @@ module FakeRedis
       context "with {nx: true, incr: true}" do
         let(:options) { {nx: true, incr: true} }
         it "should increment to the provided score only if the element is new and return the element's score" do
-          expect(@client.zadd("key", 1, "first", options)).to eq(1.0)
+          expect(@client.zadd("key", 1, "first", **options)).to eq(1.0)
           expect(@client.zscore("key", "first")).to eq(1.0)
 
-          expect(@client.zadd("key", 2, "second", options)).to eq(2.0)
+          expect(@client.zadd("key", 2, "second", **options)).to eq(2.0)
           expect(@client.zscore("key", "second")).to eq(2.0)
 
-          expect(@client.zadd("key", 99, "first", options)).to be_nil
+          expect(@client.zadd("key", 99, "first", **options)).to be_nil
           expect(@client.zscore("key", "first")).to eq(1.0)
         end
       end
@@ -699,11 +699,11 @@ module FakeRedis
       context "with {nx: true, ch: true}" do
         let(:options) { {nx: true, ch: true} }
         it "should add only new elements, not update existing elements, and return the number of added elements" do
-          expect(@client.zadd("key", 1, "first", options)).to eq(true)
-          expect(@client.zadd("key", 1, "first", options)).to eq(false)
+          expect(@client.zadd("key", 1, "first", **options)).to eq(true)
+          expect(@client.zadd("key", 1, "first", **options)).to eq(false)
 
           # add two new elements
-          expect(@client.zadd("key", [99, "first", 2, "second", 3, "third"], options)).to eq(2)
+          expect(@client.zadd("key", [99, "first", 2, "second", 3, "third"], **options)).to eq(2)
           expect(@client.zscore("key", "first")).to eq(1.0)
         end
       end
@@ -712,19 +712,19 @@ module FakeRedis
         let(:options) { {nx: true, incr: true, ch: true} }
 
         it "should add only new elements" do
-          expect(@client.zadd("key", 1, "first", options)).to eq(1.0)
-          expect(@client.zadd("key", 99, "first", options)).to be_nil
+          expect(@client.zadd("key", 1, "first", **options)).to eq(1.0)
+          expect(@client.zadd("key", 99, "first", **options)).to be_nil
           expect(@client.zscore("key", "first")).to eq(1.0)
         end
 
         # when INCR is present, return value is always the new score of member
         it "should return the score of the new member" do
-          expect(@client.zadd("key", 2, "second", options)).to eq(2.0)
+          expect(@client.zadd("key", 2, "second", **options)).to eq(2.0)
         end
 
         it "should return nil when the member already exists" do
           @client.zadd("key", 1, "first")
-          expect(@client.zadd("key", 99, "first", options)).to be_nil
+          expect(@client.zadd("key", 99, "first", **options)).to be_nil
         end
       end
 
@@ -733,12 +733,12 @@ module FakeRedis
         before { @client.zadd("key", 1, "existing") }
 
         it "should return nil if the member does not already exist" do
-          expect(@client.zadd("key", 1, "new1", options)).to be_nil
+          expect(@client.zadd("key", 1, "new1", **options)).to be_nil
           expect(@client.zscore("key", "new1")).to be_nil
         end
 
         it "should increment only existing elements" do
-          expect(@client.zadd("key", [11, "existing"], options)).to eq(12.0)
+          expect(@client.zadd("key", [11, "existing"], **options)).to eq(12.0)
           expect(@client.zscore("key", "existing")).to eq(12.0)
         end
       end
@@ -748,8 +748,8 @@ module FakeRedis
         it "should return the number of updated elements and not add new members" do
           @client.zadd("key", 1, "first")
 
-          expect(@client.zadd("key", 99, "first", options)).to eq(true)
-          expect(@client.zadd("key", [100, "first", 2, "second"], options)).to eq(1.0)
+          expect(@client.zadd("key", 99, "first", **options)).to eq(true)
+          expect(@client.zadd("key", [100, "first", 2, "second"], **options)).to eq(1.0)
           expect(@client.zscore("key", "second")).to be_nil
         end
       end
@@ -760,11 +760,11 @@ module FakeRedis
 
         # when INCR is present, return value is always the new score of member
         it "should return the new score of the inserted member" do
-          expect(@client.zadd("key", 2, "existing", options)).to eq(3.0)
+          expect(@client.zadd("key", 2, "existing", **options)).to eq(3.0)
         end
 
         it "should increment only existing elements" do
-          expect(@client.zadd("key", 1, "new", options)).to be_nil
+          expect(@client.zadd("key", 1, "new", **options)).to be_nil
         end
       end
     end

data/spec/spec_helper.rb

@@ -11,6 +11,9 @@ RSpec.configure do |config|
   # Enable memory adapter
   config.before(:each) { FakeRedis.enable }
 
+  # Set the default behavior for sadd in v5.0
+  config.before(:all) { Redis.sadd_returns_boolean = false }
+
   config.backtrace_exclusion_patterns = []
 end
 

data/spec/strings_spec.rb

@@ -183,6 +183,12 @@ module FakeRedis
       expect { @client.mget }.to raise_error(Redis::CommandError)
     end
 
+    it 'raises an argument error when the data is a hash' do
+      @client.hincrby("key1", "cont1", 5)
+
+      expect { @client.mget("key1") }.to raise_error(Redis::CommandError)
+    end
+
     it "should set multiple keys to multiple values" do
       @client.mset(:key1, "value1", :key2, "value2")
 
@@ -242,6 +248,11 @@ module FakeRedis
       expect(@client.ttl("key1")).to eq(30)
     end
 
+    it "should raise an error if a non-integer is provided as the expiration" do
+      expect { @client.setex("key1", 1.5, "value1") }.to raise_error(Redis::CommandError)
+      expect { @client.set("key1", "value1", ex: 1.5) }.to raise_error(Redis::CommandError)
+    end
+
     it "should set the value of a key, only if the key does not exist" do
       expect(@client.setnx("key1", "test value")).to eq(true)
       expect(@client.setnx("key1", "new value")).to eq(false)

data/spec/support/shared_examples/bitwise_operation.rb

@@ -5,7 +5,7 @@ shared_examples_for "a bitwise operation" do |operator|
 
   it "should not create destination key if nothing found" do
     expect(@client.bitop(operator, "dest1", "nothing_here1")).to eq(0)
-    expect(@client.exists("dest1")).to eq(false)
+    expect(@client.exists?("dest1")).to eq(false)
   end
 
   it "should accept operator as a case-insensitive symbol" do

data/spec/transactions_spec.rb

@@ -85,7 +85,7 @@ module FakeRedis
       it "returns true if the nested hash command succeeds" do
         responses = @client.multi { |multi| multi.hset('hash', 'key', 'value') }
 
-        expect(responses[0]).to eq(true)
+        expect(responses[0]).to eq(1)
       end
     end
 
@@ -94,8 +94,8 @@ module FakeRedis
         @client.sadd('set', 'member1')
 
         responses = @client.multi do |multi|
-          multi.sadd('set', 'member1')
-          multi.sadd('set', 'member2')
+          multi.sadd?('set', 'member1')
+          multi.sadd?('set', 'member2')
         end
 
         expect(responses).to eq([false, true])

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fakeredis
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.9.1
 platform: ruby
 authors:
 - Guillermo Iguaran
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-03-04 00:00:00.000000000 Z
+date: 2023-04-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.8'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '4.1'
+        version: '4.8'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '3.0'
+        version: '3'
 description: Fake (In-memory) driver for redis-rb. Useful for testing environment
   and machines without Redis.
 email:
@@ -46,8 +46,9 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- ".github/workflows/codeql.yml"
+- ".github/workflows/ruby.yml"
 - ".gitignore"
-- ".travis.yml"
 - Gemfile
 - LICENSE
 - README.md
@@ -96,7 +97,7 @@ homepage: https://guilleiguaran.github.com/fakeredis
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -111,8 +112,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: Fake (In-memory) driver for redis-rb.
 test_files:

data/.travis.yml

@@ -1,17 +0,0 @@
-language: ruby
-cache: bundler
-# Use the faster container based infrastructure
-# http://blog.travis-ci.com/2014-12-17-faster-builds-with-container-based-infrastructure/
-sudo: false
-
-rvm:
-  - 2.4
-  - 2.5
-  - 2.6
-  - ruby-head
-  - jruby
-  - rbx-2
-
-matrix:
-  allow_failures:
-    - rvm: rbx-2