fakeredis 0.5.0 → 0.8.0

data/spec/bitop_command_spec.rb

@@ -0,0 +1,209 @@
+require 'spec_helper'
+
+module FakeRedis
+  describe "#bitop" do
+    before(:all) do
+      @client = Redis.new
+    end
+
+    before(:each) do
+      @client.discard rescue nil
+    end
+
+    it 'raises an argument error when passed unsupported operation' do
+      expect { @client.bitop("meh", "dest1", "key1") }.to raise_error(Redis::CommandError)
+    end
+
+    describe "or" do
+      it_should_behave_like "a bitwise operation", "or"
+
+      it "should apply bitwise or operation" do
+        @client.setbit("key1", 0, 0)
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 2, 1)
+        @client.setbit("key1", 3, 0)
+
+        @client.setbit("key2", 0, 1)
+        @client.setbit("key2", 1, 1)
+        @client.setbit("key2", 2, 0)
+        @client.setbit("key2", 3, 0)
+
+        expect(@client.bitop("or", "dest1", "key1", "key2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(3)
+        expect(@client.getbit("dest1", 0)).to eq(1)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(0)
+      end
+
+      it "should apply bitwise or operation with empty values" do
+        @client.setbit("key1", 1, 1)
+
+        expect(@client.bitop("or", "dest1", "key1", "nothing_here1", "nothing_here2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(1)
+        expect(@client.getbit("dest1", 0)).to eq(0)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(0)
+      end
+
+      it "should apply bitwise or operation with multiple keys" do
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 3, 1)
+
+        @client.setbit("key2", 5, 1)
+        @client.setbit("key2", 10, 1)
+
+        @client.setbit("key3", 13, 1)
+        @client.setbit("key3", 15, 1)
+
+        expect(@client.bitop("or", "dest1", "key1", "key2", "key3")).to eq(2)
+        expect(@client.bitcount("dest1")).to eq(6)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(1)
+        expect(@client.getbit("dest1", 5)).to eq(1)
+        expect(@client.getbit("dest1", 10)).to eq(1)
+        expect(@client.getbit("dest1", 13)).to eq(1)
+        expect(@client.getbit("dest1", 15)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(0)
+        expect(@client.getbit("dest1", 12)).to eq(0)
+      end
+    end
+
+    describe "and" do
+      it_should_behave_like "a bitwise operation", "and"
+
+      it "should apply bitwise and operation" do
+        @client.setbit("key1", 0, 1)
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 2, 0)
+
+        @client.setbit("key2", 0, 0)
+        @client.setbit("key2", 1, 1)
+        @client.setbit("key2", 2, 1)
+
+        expect(@client.bitop("and", "dest1", "key1", "key2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(1)
+        expect(@client.getbit("dest1", 0)).to eq(0)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(0)
+      end
+
+      it "should apply bitwise and operation with empty values" do
+        @client.setbit("key1", 1, 1)
+
+        expect(@client.bitop("and", "dest1", "key1", "nothing_here")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(1)
+        expect(@client.getbit("dest1", 0)).to eq(0)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(0)
+      end
+
+      it "should apply bitwise and operation with multiple keys" do
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 2, 1)
+        @client.setbit("key1", 3, 1)
+        @client.setbit("key1", 4, 1)
+
+        @client.setbit("key2", 2, 1)
+        @client.setbit("key2", 3, 1)
+        @client.setbit("key2", 4, 1)
+        @client.setbit("key2", 5, 1)
+
+        @client.setbit("key3", 2, 1)
+        @client.setbit("key3", 4, 1)
+        @client.setbit("key3", 5, 1)
+        @client.setbit("key3", 6, 1)
+
+        expect(@client.bitop("and", "dest1", "key1", "key2", "key3")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(2)
+        expect(@client.getbit("dest1", 1)).to eq(0)
+        expect(@client.getbit("dest1", 2)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(0)
+        expect(@client.getbit("dest1", 4)).to eq(1)
+        expect(@client.getbit("dest1", 5)).to eq(0)
+        expect(@client.getbit("dest1", 6)).to eq(0)
+      end
+    end
+
+    describe "xor" do
+      it_should_behave_like "a bitwise operation", "xor"
+
+      it "should apply bitwise xor operation" do
+        @client.setbit("key1", 0, 0)
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 2, 0)
+        @client.setbit("key1", 3, 0)
+
+        @client.setbit("key2", 0, 1)
+        @client.setbit("key2", 1, 1)
+        @client.setbit("key2", 2, 1)
+        @client.setbit("key2", 3, 0)
+
+        expect(@client.bitop("xor", "dest1", "key1", "key2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(2)
+        expect(@client.getbit("dest1", 0)).to eq(1)
+        expect(@client.getbit("dest1", 1)).to eq(0)
+        expect(@client.getbit("dest1", 2)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(0)
+      end
+
+      it "should apply bitwise xor operation with empty values" do
+        @client.setbit("key1", 1, 1)
+
+        expect(@client.bitop("xor", "dest1", "key1", "nothing_here1", "nothing_here2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(1)
+        expect(@client.getbit("dest1", 0)).to eq(0)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(0)
+      end
+
+      it "should apply bitwise xor operation with multiple keys" do
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 3, 1)
+        @client.setbit("key1", 5, 1)
+        @client.setbit("key1", 6, 1)
+
+        @client.setbit("key2", 2, 1)
+        @client.setbit("key2", 3, 1)
+        @client.setbit("key2", 4, 1)
+        @client.setbit("key2", 6, 1)
+
+        expect(@client.bitop("xor", "dest1", "key1", "key2")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(4)
+        expect(@client.getbit("dest1", 1)).to eq(1)
+        expect(@client.getbit("dest1", 2)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(0)
+        expect(@client.getbit("dest1", 4)).to eq(1)
+        expect(@client.getbit("dest1", 5)).to eq(1)
+        expect(@client.getbit("dest1", 6)).to eq(0)
+      end
+    end
+
+    describe "not" do
+      it 'raises an argument error when not passed any keys' do
+        expect { @client.bitop("not", "destkey") }.to raise_error(Redis::CommandError)
+      end
+
+      it 'raises an argument error when not passed too many keys' do
+        expect { @client.bitop("not", "destkey", "key1", "key2") }.to raise_error(Redis::CommandError)
+      end
+
+      it "should apply bitwise negation operation" do
+        @client.setbit("key1", 1, 1)
+        @client.setbit("key1", 3, 1)
+        @client.setbit("key1", 5, 1)
+
+        expect(@client.bitop("not", "dest1", "key1")).to eq(1)
+        expect(@client.bitcount("dest1")).to eq(5)
+        expect(@client.getbit("dest1", 0)).to eq(1)
+        expect(@client.getbit("dest1", 1)).to eq(0)
+        expect(@client.getbit("dest1", 2)).to eq(1)
+        expect(@client.getbit("dest1", 3)).to eq(0)
+        expect(@client.getbit("dest1", 4)).to eq(1)
+        expect(@client.getbit("dest1", 5)).to eq(0)
+        expect(@client.getbit("dest1", 6)).to eq(1)
+        expect(@client.getbit("dest1", 7)).to eq(1)
+      end
+    end
+  end
+end

data/spec/command_executor_spec.rb

@@ -0,0 +1,15 @@
+require 'spec_helper'
+
+RSpec.describe FakeRedis::CommandExecutor do
+  
+  let(:redis) { Redis.new }
+
+  context '#write' do
+    it 'does not modify its argument' do
+      command = [:get, 'key']
+      redis.write(command)
+      expect(command).to eql([:get, 'key'])
+    end
+  end
+
+end

data/spec/compatibility_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 module FakeRedis
   describe "Compatibility" do
     it "should be accessible through FakeRedis::Redis" do
-      lambda { FakeRedis::Redis.new }.should_not raise_error
+      expect { FakeRedis::Redis.new }.not_to raise_error
     end
   end
 end

data/spec/connection_spec.rb

@@ -9,7 +9,7 @@ module FakeRedis
 
   if fakeredis?
     it "should authenticate to the server" do
-      @client.auth("pass").should be == "OK"
+      expect(@client.auth("pass")).to eq("OK")
     end
 
     it "should re-use the same instance with the same host & port" do
@@ -18,40 +18,40 @@ module FakeRedis
       @client3 = Redis.new(:host => "localhost", :port => 5678)
 
       @client1.set("key1", "1")
-      @client2.get("key1").should be == "1"
-      @client3.get("key1").should be_nil
+      expect(@client2.get("key1")).to eq("1")
+      expect(@client3.get("key1")).to be_nil
 
       @client2.set("key2", "2")
-      @client1.get("key2").should be == "2"
-      @client3.get("key2").should be_nil
+      expect(@client1.get("key2")).to eq("2")
+      expect(@client3.get("key2")).to be_nil
 
       @client3.set("key3", "3")
-      @client1.get("key3").should be_nil
-      @client2.get("key3").should be_nil
+      expect(@client1.get("key3")).to be_nil
+      expect(@client2.get("key3")).to be_nil
 
-      @client1.dbsize.should be == 2
-      @client2.dbsize.should be == 2
-      @client3.dbsize.should be == 1
+      expect(@client1.dbsize).to eq(2)
+      expect(@client2.dbsize).to eq(2)
+      expect(@client3.dbsize).to eq(1)
     end
 
     it "should connect to a specific database" do
       @client1 = Redis.new(:host => "localhost", :port => 1234, :db => 0)
       @client1.set("key1", "1")
       @client1.select(0)
-      @client1.get("key1").should be == "1"
+      expect(@client1.get("key1")).to eq("1")
 
       @client2 = Redis.new(:host => "localhost", :port => 1234, :db => 1)
       @client2.set("key1", "1")
       @client2.select(1)
-      @client2.get("key1").should == "1"
+      expect(@client2.get("key1")).to eq("1")
     end
 
     it "should not error with shutdown" do
-      lambda { @client.shutdown }.should_not raise_error
+      expect { @client.shutdown }.not_to raise_error
     end
 
     it "should not error with quit" do
-      lambda { @client.quit }.should_not raise_error
+      expect { @client.quit }.not_to raise_error
     end
   end
 
@@ -60,26 +60,26 @@ module FakeRedis
       @client2 = Redis.new(:host => "localhost", :port => 6379, :db => 2)
 
       @client1.set("key1", "one")
-      @client1.get("key1").should be == "one"
+      expect(@client1.get("key1")).to eq("one")
 
       @client2.set("key2", "two")
-      @client2.get("key2").should be == "two"
+      expect(@client2.get("key2")).to eq("two")
 
-      @client1.get("key1").should be == "one"
+      expect(@client1.get("key1")).to eq("one")
     end
 
     it "should not error with a disconnected client" do
       @client1 = Redis.new
-      @client1.client.disconnect
-      @client1.get("key1").should be_nil
+      @client1.close
+      expect(@client1.get("key1")).to be_nil
     end
 
     it "should echo the given string" do
-      @client.echo("something").should == "something"
+      expect(@client.echo("something")).to eq("something")
     end
 
     it "should ping the server" do
-      @client.ping.should == "PONG"
+      expect(@client.ping).to eq("PONG")
     end
   end
 end

data/spec/fakeredis_spec.rb

@@ -0,0 +1,73 @@
+require 'spec_helper'
+
+describe FakeRedis do
+  after { described_class.disable }
+
+  describe '.enable' do
+    it 'in memory connection' do
+      described_class.enable
+      expect(described_class.enabled?).to be_truthy
+    end
+  end
+
+  describe '.disable' do
+    before { described_class.enable }
+
+    it 'in memory connection' do
+      described_class.disable
+      expect(described_class.enabled?).to be_falsy
+    end
+  end
+
+  describe '.disabling' do
+    context 'FakeRedis is enabled' do
+      before { described_class.enable }
+
+      it 'in memory connection' do
+        described_class.disabling do
+          expect(described_class.enabled?).to be_falsy
+        end
+
+        expect(described_class.enabled?).to be_truthy
+      end
+    end
+
+    context 'FakeRedis is disabled' do
+      before { described_class.disable }
+
+      it 'in memory connection' do
+        described_class.disabling do
+          expect(described_class.enabled?).to be_falsy
+        end
+
+        expect(described_class.enabled?).to be_falsy
+      end
+    end
+  end
+
+  describe '.enabling' do
+    context 'FakeRedis is enabled' do
+      before { described_class.enable }
+
+      it 'in memory connection' do
+        described_class.enabling do
+          expect(described_class.enabled?).to be_truthy
+        end
+
+        expect(described_class.enabled?).to be_truthy
+      end
+    end
+
+    context 'FakeRedis is disabled' do
+      before { described_class.disable }
+
+      it 'in memory connection' do
+        described_class.enabling do
+          expect(described_class.enabled?).to be_truthy
+        end
+
+        expect(described_class.enabled?).to be_falsy
+      end
+    end
+  end
+end

data/spec/geo_set_spec.rb

@@ -0,0 +1,164 @@
+require "spec_helper"
+
+module FakeRedis
+  describe "GeoMethods" do
+    before do
+      @client = Redis.new
+    end
+
+    describe "#geoadd" do
+      it "should raise when not enough arguments" do
+        expect { @client.geoadd("Sicily", []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'geoadd' command")
+        expect { @client.geoadd("Sicily", [13.361389, 38.115556]) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'geoadd' command")
+      end
+
+      it "should add items to the set" do
+        added_items_count = add_sicily
+        expect(added_items_count).to eq(2)
+      end
+
+      it "should update existing items" do
+        @client.geoadd("Sicily", 13.361389, 38.115556, "Palermo")
+        added_items_count = @client.geoadd("Sicily", 13, 39, "Palermo", 15.087269, 37.502669, "Catania")
+        expect(added_items_count).to eq(1)
+      end
+    end
+
+    describe "#geodist" do
+      before do
+        add_sicily
+      end
+
+      it "should return destination between two elements" do
+        distance_in_meters = @client.geodist("Sicily", "Palermo", "Catania")
+        expect(distance_in_meters).to eq("166412.6051")
+
+        distance_in_feet = @client.geodist("Sicily", "Palermo", "Catania", "ft")
+        expect(distance_in_feet).to eq("545973.1137")
+      end
+
+      it "should raise for unknown unit name" do
+        expect {
+          @client.geodist("Sicily", "Palermo", "Catania", "unknown")
+        }.to raise_error(Redis::CommandError, "ERR unsupported unit provided. please use m, km, ft, mi")
+      end
+
+      it "should return nil when element is missing" do
+        expect(@client.geodist("Sicily", "Palermo", "Rome")).to be_nil
+      end
+    end
+
+    describe "#geohash" do
+      before do
+        add_sicily
+      end
+
+      it "should raise when not enough arguments" do
+        expect { @client.geohash("Sicily", []) }.to raise_error(Redis::CommandError, "ERR wrong number of arguments for 'geohash' command")
+      end
+
+      it "should return geohashes" do
+        geohash = @client.geohash("Sicily", "Palermo")
+        expect(geohash).to eq(["sqc8b49rny"])
+
+        geohashes = @client.geohash("Sicily", ["Palermo", "Catania"])
+        expect(geohashes).to eq(["sqc8b49rny", "sqdtr74hyu"])
+      end
+
+      it "should return nils for nonexistent elements" do
+        geohashes = @client.geohash("Sicily", ["Palermo", "Rome"])
+        expect(geohashes).to eq(["sqc8b49rny", nil])
+      end
+    end
+
+    describe "#geopos" do
+      it "should return positions (longitude, latitude) for elements" do
+        add_sicily
+        position = @client.geopos("Sicily", "Catania")
+        expect(position).to eq([["15.087269", "37.502669"]])
+
+        positions = @client.geopos("Sicily", ["Palermo", "Catania"])
+        expect(positions).to eq([["13.361389", "38.115556"], ["15.087269", "37.502669"]])
+      end
+
+      it "should return nil for nonexistent elements" do
+        expect(@client.geopos("nonexistent", "nonexistent2")).to be_nil
+        add_sicily
+
+        position = @client.geopos("Sicily", "Rome")
+        expect(position).to eq([nil])
+
+        positions = @client.geopos("Sicily", ["Rome", "Catania"])
+        expect(positions).to eq([nil, ["15.087269", "37.502669"]])
+      end
+    end
+
+    describe "#georadius" do
+      before do
+        add_sicily
+      end
+
+      it "should return members within specified radius" do
+        nearest_cities = @client.georadius("Sicily", 15, 37, 100, "km")
+        expect(nearest_cities).to eq(["Catania"])
+      end
+
+      it "should sort returned members" do
+        nearest_cities = @client.georadius("Sicily", 15, 37, 200, "km", sort: "asc")
+        expect(nearest_cities).to eq(["Catania", "Palermo"])
+
+        farthest_cities = @client.georadius("Sicily", 15, 37, 200, "km", sort: "desc")
+        expect(farthest_cities).to eq(["Palermo", "Catania"])
+      end
+
+      it "should return specified count of members" do
+        city = @client.georadius("Sicily", 15, 37, 200, "km", sort: "asc", count: 1)
+        expect(city).to eq(["Catania"])
+      end
+
+      it "should include additional info for members" do
+        cities = @client.georadius("Sicily", 15, 37, 200, "km", "WITHDIST")
+        expect(cities).to eq([["Palermo", "190.6009"], ["Catania", "56.4883"]])
+
+        cities = @client.georadius("Sicily", 15, 37, 200, "km", "WITHCOORD")
+        expect(cities).to eq [["Palermo", ["13.361389", "38.115556"]], ["Catania", ["15.087269", "37.502669"]]]
+
+        cities = @client.georadius("Sicily", 15, 37, 200, "km", "WITHDIST", "WITHCOORD")
+        expect(cities).to eq(
+          [["Palermo", "190.6009", ["13.361389", "38.115556"]],
+           ["Catania", "56.4883", ["15.087269", "37.502669"]]]
+        )
+      end
+    end
+
+    describe "#georadiusbymember" do
+      before do
+        add_sicily
+      end
+
+      it "should sort returned members" do
+        nearest_cities = @client.georadiusbymember("Sicily", "Catania", 200, "km", sort: "asc")
+        expect(nearest_cities).to eq(["Catania", "Palermo"])
+
+        farthest_cities = @client.georadiusbymember("Sicily", "Catania", 200, "km", sort: "desc")
+        expect(farthest_cities).to eq(["Palermo", "Catania"])
+      end
+
+      it "should limit number of returned members" do
+        city = @client.georadiusbymember("Sicily", "Catania", 100, "km", count: 1)
+        expect(city).to eq(["Catania"])
+      end
+
+      it "should include extra info if requested" do
+        city = @client.georadiusbymember("Sicily", "Catania", 200, "km", sort: :desc, options: :WITHDIST, count: 1)
+        expect(city).to eq([["Palermo", "166.4126"]])
+      end
+    end
+
+    private
+
+    def add_sicily
+      @client.geoadd("Sicily", 13.361389, 38.115556, "Palermo", 15.087269, 37.502669, "Catania")
+    end
+  end
+end