fakeredis 0.7.0 → 0.8.0

data/spec/hyper_log_logs_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+module FakeRedis
+  describe "HyperLogLogsMethods" do
+    let(:redis) { Redis.new }
+
+    it "should add item to hyperloglog" do
+      expect(redis.pfadd("hll", "val")).to eq(true)
+      expect(redis.pfcount("hll")).to eq(1)
+    end
+
+    it "should not add duplicated item to hyperloglog" do
+      redis.pfadd("hll", "val")
+      expect(redis.pfadd("hll", "val")).to eq(false)
+      expect(redis.pfcount("hll")).to eq(1)
+    end
+
+    it "should not add multiple items to hyperloglog" do
+      expect(redis.pfadd("hll", ["val1", "val2"])).to eq(true)
+      expect(redis.pfcount("hll")).to eq(2)
+    end
+
+    it "should return zero as cardinality for nonexistent key" do
+      expect(redis.pfcount("nonexistent")).to eq(0)
+    end
+
+    it "should return cardinality of union of hyperloglogs" do
+      redis.pfadd("hll1", ["val1", "val2"])
+      redis.pfadd("hll2", ["val2", "val3"])
+      expect(redis.pfcount("hll1", "hll2")).to eq(3)
+    end
+
+    it "should error if an empty list of keys is given" do
+      expect { redis.pfcount([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'pfcount' command")
+    end
+
+    it "should merge hyperloglogs" do
+      redis.pfadd("hll1", ["val1", "val2"])
+      redis.pfadd("hll2", ["val2", "val3"])
+      expect(redis.pfmerge("hll3", "hll1", "hll2")).to eq(true)
+      expect(redis.pfcount("hll3")).to eq(3)
+    end
+
+    it "should merge nonexistent hyperloglogs with others" do
+      redis.pfadd("hll1", "val")
+      expect(redis.pfmerge("hll3", "hll1", "nonexistent")).to eq(true)
+      expect(redis.pfcount("hll3")).to eq(1)
+    end
+  end
+end

data/spec/keys_spec.rb

@@ -7,26 +7,33 @@ module FakeRedis
       @client = Redis.new
     end
 
-    it "should delete a key" do
-      @client.set("key1", "1")
-      @client.set("key2", "2")
-      @client.del("key1", "key2")
+    [:del, :unlink].each do |command|
+      it "should #{command} a key" do
+        @client.set("key1", "1")
+        @client.set("key2", "2")
+        @client.public_send(command, "key1", "key2")
 
-      expect(@client.get("key1")).to eq(nil)
-    end
+        expect(@client.get("key1")).to eq(nil)
+      end
 
-    it "should delete multiple keys" do
-      @client.set("key1", "1")
-      @client.set("key2", "2")
-      @client.del(["key1", "key2"])
+      it "should #{command} multiple keys" do
+        @client.set("key1", "1")
+        @client.set("key2", "2")
+        @client.public_send(command, ["key1", "key2"])
 
-      expect(@client.get("key1")).to eq(nil)
-      expect(@client.get("key2")).to eq(nil)
-    end
+        expect(@client.get("key1")).to eq(nil)
+        expect(@client.get("key2")).to eq(nil)
+      end
 
-    it "should error deleting no keys" do
-      expect { @client.del }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'del' command")
-      expect { @client.del [] }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'del' command")
+      it "should return the number of '#{command}'ed keys" do
+        @client.set("key1", "1")
+        expect(@client.public_send(command, ["key1", "key2"])).to eq(1)
+      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
     end
 
     it "should return true when setnx keys that don't exist" do
@@ -130,6 +137,13 @@ module FakeRedis
       expect(@client.exists("key1")).to be false
     end
 
+    it "should get integer and string keys" do
+      @client.set("key1", "1")
+      @client.set(2, "2")
+
+      expect(@client.mget("key1", 2)).to eq(["1", "2"])
+    end
+
     it "should find all keys matching the given pattern" do
       @client.set("key:a", "1")
       @client.set("key:b", "2")
@@ -483,6 +497,17 @@ module FakeRedis
       end
     end
 
+    describe "#psetex" do
+      it "should set a key's time to live in milliseconds" do
+        allow(Time).to receive(:now).and_return(1000)
+        @client.psetex("key", 2200, "value")
+        expect(@client.pttl("key")).to be_within(0.1).of(2200)
+      end
+
+      it "should return 'OK'" do
+        expect(@client.psetex("key", 1000, "value")).to eq("OK")
+      end
+    end
   end
 end
 

data/spec/lists_spec.rb

@@ -196,7 +196,7 @@ module FakeRedis
       expect(@client.lrange("key1", 0, -1)).to eq(["one", "two"])
     end
 
-    it "should remove the last element in a list, append it to another list and return it" do
+    it "rpoplpush should remove the last element in a list, append it to another list and return it" do
       @client.rpush("key1", "one")
       @client.rpush("key1", "two")
       @client.rpush("key1", "three")
@@ -207,12 +207,29 @@ module FakeRedis
       expect(@client.lrange("key2", 0, -1)).to eq(["three"])
     end
 
+    it "brpoplpush should remove the last element in a list, append it to another list and return it" do
+      @client.rpush("key1", "one")
+      @client.rpush("key1", "two")
+      @client.rpush("key1", "three")
+
+      expect(@client.brpoplpush("key1", "key2")).to eq("three")
+
+      expect(@client.lrange("key1", 0, -1)).to eq(["one", "two"])
+      expect(@client.lrange("key2", 0, -1)).to eq(["three"])
+    end
+
     context 'when the source list is empty' do
       it 'rpoplpush does not add anything to the destination list' do
         @client.rpoplpush("source", "destination")
 
         expect(@client.lrange("destination", 0, -1)).to eq([])
       end
+
+      it 'brpoplpush does not add anything to the destination list' do
+        expect(@client.brpoplpush("source", "destination")).to be_nil
+
+        expect(@client.lrange("destination", 0, -1)).to eq([])
+      end
     end
 
     it "should append a value to a list" do

data/spec/memory_spec.rb

@@ -86,16 +86,12 @@ RSpec.describe FakeRedis do
   end
 
   describe '#client' do
-    it 'returns 1 when command is :setname' do
-      expect(redis.write([:client, :setname])).to eq 1
+    it 'returns OK when command is :setname' do
+      expect(redis.client(:setname, 'my-client-01')).to eq 'OK'
     end
 
     it 'returns nil when command is :getname' do
-      expect(redis.write([:client, :getname])).to eq nil
-    end
-
-    it 'returns true when the comment is :client with an argument' do
-      expect(redis.write([:client, :client, :list])).to eq 1
+      expect(redis.client(:getname)).to eq nil
     end
 
     it 'raises error for other commands' do

data/spec/server_spec.rb

@@ -97,4 +97,18 @@ module FakeRedis
       end
     end
   end
+
+  describe 'custom options' do
+    describe 'version' do
+      it 'reports default Redis version when not provided' do
+        client = Redis.new
+        expect(client.info['redis_version']).to eq Redis::Connection::DEFAULT_REDIS_VERSION
+      end
+
+      it 'creates with and reports properly' do
+        client = Redis.new(version: '3.3.0')
+        expect(client.info['redis_version']).to eq '3.3.0'
+      end
+    end
+  end
 end

data/spec/sets_spec.rb

@@ -19,6 +19,7 @@ module FakeRedis
       expect { @client.sinter([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sinter' command")
       expect { @client.sunion(*[]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sunion' command")
       expect { @client.sunion([]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'sunion' command")
+      expect { @client.srem("key", []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'srem' command")
 
       expect(@client.smembers("key")).to be_empty
     end
@@ -242,7 +243,7 @@ module FakeRedis
         it 'is an array of one random element from the set' do
           random_elements = @client.srandmember("key1", 1)
 
-          expect([['a'], ['b'], ['c']].include?(@client.srandmember("key1", 1))).to be true
+          expect([['a'], ['b'], ['c']].include?(random_elements)).to be true
         end
       end
 

data/spec/sorted_sets_spec.rb

@@ -103,6 +103,34 @@ module FakeRedis
       expect(@client.exists("key")).to eq(false)
     end
 
+    it "should pop members with the highest scores from sorted set" do
+      @client.zadd("key", [1, "val1", 2, "val2", 3, "val3"])
+      expect(@client.zpopmax("key")).to eq(["val3", 3.0])
+      expect(@client.zpopmax("key", 3)).to eq([["val2", 2.0], ["val1", 1.0]])
+      expect(@client.zpopmax("nonexistent")).to eq(nil)
+    end
+
+    it "should pop members with the lowest scores from sorted set" do
+      @client.zadd("key", [1, "val1", 2, "val2", 3, "val3"])
+      expect(@client.zpopmin("key")).to eq(["val1", 1.0])
+      expect(@client.zpopmin("key", 3)).to eq([["val2", 2.0], ["val3", 3.0]])
+      expect(@client.zpopmin("nonexistent")).to eq(nil)
+    end
+
+    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")).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")).to eq(nil)
+    end
+
     it "should get the number of members in a sorted set" do
       @client.zadd("key", 1, "val2")
       @client.zadd("key", 2, "val1")
@@ -147,6 +175,7 @@ module FakeRedis
 
       expect(@client.zrange("key", 0, -1)).to eq(["one", "two", "three"])
       expect(@client.zrange("key", 1, 2)).to eq(["two", "three"])
+      expect(@client.zrange("key", -50, -2)).to eq(["one", "two"])
       expect(@client.zrange("key", 0, -1, :withscores => true)).to eq([["one", 1], ["two", 2], ["three", 3]])
       expect(@client.zrange("key", 1, 2, :with_scores => true)).to eq([["two", 2], ["three", 3]])
     end
@@ -574,7 +603,7 @@ module FakeRedis
         expect(ranged).to eq %w(c b)
       end
 
-      it "should return empty array if key is not exist" do
+      it "should return empty array if key does not exist" do
         ranged = @client.zrevrangebylex "puppies", "+", "-"
         expect(ranged).to be_empty
       end
@@ -590,5 +619,154 @@ module FakeRedis
         expect(ranged).to eq %w(d c b)
       end
     end
+
+    describe "#zadd" do
+      context "with {incr: true}" do
+        before { @client.zadd("key", 1, "existing") }
+        it "should increment the element's score with the provided value" do
+          @client.zadd("key", 99, "existing", incr: true)
+          expect(@client.zscore("key", "existing")).to eq(100.0)
+
+          @client.zadd("key", 2, "new", incr: true)
+          expect(@client.zscore("key", "new")).to eq(2.0)
+        end
+
+        it "should error when trying to add multiple increment-element pairs" do
+          expect {
+            @client.zadd("key", [1, "member1", 2, "member2"], incr: true)
+          }.to raise_error(Redis::CommandError, "ERR INCR option supports a single increment-element pair")
+        end
+      end
+
+      context "with {nx: true}" do
+        before { @client.zadd("key", [1, "existing1", 2, "existing2"]) }
+        it "should add new elements but not update the scores of existing elements" do
+          @client.zadd("key", [101, "existing1", 3, "new"], nx: true)
+
+          expect(@client.zscore("key", "existing1")).to eq(1.0)
+          expect(@client.zscore("key", "new")).to eq(3.0)
+
+          @client.zadd("key", 102, "existing2", nx: true)
+          expect(@client.zscore("key", "existing2")).to eq(2.0)
+        end
+      end
+
+      context "with {xx: true}" do
+        before { @client.zadd("key", 1, "existing") }
+        it "should not add new elements" do
+          expect(@client.zadd("key", 1, "new1", xx: true)).to eq(false)
+          expect(@client.zscore("key", "new1")).to be_nil
+
+          expect(@client.zadd("key", [11, "existing", 2, "new2"], xx: true)).to eq(0)
+          expect(@client.zscore("key", "existing")).to eq(11.0)
+          expect(@client.zscore("key", "new2")).to be_nil
+        end
+      end
+
+      context "with {ch: true}" do
+        it "should return the number of new elements added plus the number of existing elements for which the score was updated" do
+          expect(@client.zadd("key", 1, "first", ch: true)).to eq(true)
+
+          expect(@client.zadd("key", [1, "first", 2, "second"], ch: true)).to eq(1.0)
+          expect(@client.zadd("key", [11, "first", 2, "second"], ch: true)).to eq(1.0)
+          expect(@client.zadd("key", [99, "first", 99, "second"], ch: true)).to eq(2.0)
+          expect(@client.zadd("key", [111, "first", 22, "second", 3, "third"], ch: true)).to eq(3.0)
+        end
+      end
+
+      context "with {nx: true, xx: true}" do
+        it "should error" do
+          expect{
+            @client.zadd("key", 1, "value", nx: true, xx: true)
+          }.to raise_error(Redis::CommandError, "ERR XX and NX options at the same time are not compatible")
+        end
+      end
+
+      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.zscore("key", "first")).to eq(1.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.zscore("key", "first")).to eq(1.0)
+        end
+      end
+
+      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)
+
+          # add two new elements
+          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
+
+      context "with {nx: true, incr: true, ch: true}" do
+        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.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)
+        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
+        end
+      end
+
+      context "with {xx: true, incr: true}" do
+        let(:options) { {xx: true, incr: true} }
+        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.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.zscore("key", "existing")).to eq(12.0)
+        end
+      end
+
+      context "with {xx: true, ch: true}" do
+        let(:options) { {xx: true, ch: true} }
+        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.zscore("key", "second")).to be_nil
+        end
+      end
+
+      context "with {xx: true, incr: true, ch: true}" do
+        let(:options) { {xx: true, incr: true, ch: true} }
+        before { @client.zadd("key", 1, "existing") }
+
+        # 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)
+        end
+
+        it "should increment only existing elements" do
+          expect(@client.zadd("key", 1, "new", options)).to be_nil
+        end
+      end
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,31 +1,17 @@
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
-$LOAD_PATH.unshift(File.dirname(__FILE__))
 require 'rspec'
-require 'fakeredis'
-require "fakeredis/rspec"
 
-require "support/shared_examples/sortable"
-require "support/shared_examples/bitwise_operation"
+$LOAD_PATH.unshift(File.join(__dir__, '..', 'lib'))
+$LOAD_PATH.unshift(File.join(__dir__, '..'))
+Dir['spec/support/**/*.rb'].each { |f| require f }
 
+require 'fakeredis'
+require "fakeredis/rspec"
 
 RSpec.configure do |config|
   # Enable memory adapter
   config.before(:each) { FakeRedis.enable }
 
-  # replaces -b -fdoc --color in .rspec
-  config.color = true
-  config.default_formatter = "doc"
   config.backtrace_exclusion_patterns = []
-
-  config.mock_with :rspec do |c|
-    # TODO: upgrade should syntax to expect syntax
-    c.syntax = [:should, :expect]
-  end
-
-  config.expect_with :rspec do |c|
-    # TODO: upgrade should syntax to expect syntax
-    c.syntax = [:should, :expect]
-  end
 end
 
 def fakeredis?