redis-store-json 3.0.0

data/redis-store-json/test/redis/factory_test.rb

@@ -0,0 +1,120 @@
+require 'test_helper'
+
+describe "Redis::Factory" do
+  describe ".create" do
+    describe "when not given any arguments" do
+      it "instantiates Redis::Store" do
+        store = Redis::Factory.create
+        store.must_be_kind_of(Redis::Store)
+        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0")
+      end
+    end
+
+    describe "when given a Hash" do
+      it "uses specified host" do
+        store = Redis::Factory.create :host => "localhost"
+        store.to_s.must_equal("Redis Client connected to localhost:6379 against DB 0")
+      end
+
+      it "uses specified port" do
+        store = Redis::Factory.create :host => "localhost", :port => 6380
+        store.to_s.must_equal("Redis Client connected to localhost:6380 against DB 0")
+      end
+
+      it "uses specified db" do
+        store = Redis::Factory.create :host => "localhost", :port => 6380, :db => 13
+        store.to_s.must_equal("Redis Client connected to localhost:6380 against DB 13")
+      end
+
+      it "uses specified namespace" do
+        store = Redis::Factory.create :namespace => "theplaylist"
+        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+      end
+
+      it "uses specified key_prefix as namespace" do
+        store = Redis::Factory.create :key_prefix => "theplaylist"
+        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+      end
+
+      it "uses specified password" do
+        store = Redis::Factory.create :password => "secret"
+        store.instance_variable_get(:@client).password.must_equal("secret")
+      end
+
+      it "allows json strategy option" do
+        store = Redis::Factory.create :strategy => :json
+        store.must_be_kind_of(Redis::Store::Strategy::Json)
+      end
+
+      it "allows marshal strategy option" do
+        store = Redis::Factory.create :strategy => :marshal
+        store.must_be_kind_of(Redis::Store::Strategy::Marshal)
+      end
+
+      it "allows yaml strategy option" do
+        store = Redis::Factory.create :strategy => :yaml
+        store.must_be_kind_of(Redis::Store::Strategy::Yaml)
+      end
+
+      it "allows false strategy option" do
+        store = Redis::Factory.create :strategy => false
+        store.wont_be_kind_of(Redis::Store::Strategy::Json)
+        store.wont_be_kind_of(Redis::Store::Strategy::Marshal)
+        store.wont_be_kind_of(Redis::Store::Strategy::Yaml)
+      end
+
+      it "defaults to marshal strategy" do
+        store = Redis::Factory.create
+        store.must_be_kind_of(Redis::Store::Strategy::Marshal)
+      end
+
+      it "should instantiate a Redis::DistributedStore store" do
+        store = Redis::Factory.create(
+          {:host => "localhost", :port => 6379},
+          {:host => "localhost", :port => 6380}
+        )
+        store.must_be_kind_of(Redis::DistributedStore)
+        store.nodes.map {|node| node.to_s }.must_equal([
+          "Redis Client connected to localhost:6379 against DB 0",
+          "Redis Client connected to localhost:6380 against DB 0",
+        ])
+      end
+    end
+
+    describe "when given a String" do
+      it "uses specified host" do
+        store = Redis::Factory.create "redis://127.0.0.1"
+        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0")
+      end
+
+      it "uses specified port" do
+        store = Redis::Factory.create "redis://127.0.0.1:6380"
+        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6380 against DB 0")
+      end
+
+      it "uses specified db" do
+        store = Redis::Factory.create "redis://127.0.0.1:6380/13"
+        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6380 against DB 13")
+      end
+
+      it "uses specified namespace" do
+        store = Redis::Factory.create "redis://127.0.0.1:6379/0/theplaylist"
+        store.to_s.must_equal("Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist")
+      end
+
+      it "uses specified password" do
+        store = Redis::Factory.create "redis://:secret@127.0.0.1:6379/0/theplaylist"
+        store.instance_variable_get(:@client).password.must_equal("secret")
+      end
+
+      it "instantiates Redis::DistributedStore" do
+        store = Redis::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380"
+        store.must_be_kind_of(Redis::DistributedStore)
+        store.nodes.map {|node| node.to_s }.must_equal([
+          "Redis Client connected to 127.0.0.1:6379 against DB 0",
+          "Redis Client connected to 127.0.0.1:6380 against DB 0",
+        ])
+      end
+    end
+  end
+end

data/redis-store-json/test/redis/store/interface_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class InterfacedRedis < Redis
+  include Redis::Store::Interface
+end
+
+describe Redis::Store::Interface do
+  before do
+    @r = InterfacedRedis.new
+  end
+
+  it "should get an element" do
+    lambda { @r.get("key", :option => true) } #.wont_raise ArgumentError
+  end
+
+  it "should set an element" do
+    lambda { @r.set("key", "value", :option => true) } #.wont_raise ArgumentError
+  end
+
+  it "should setnx an element" do
+    lambda { @r.setnx("key", "value", :option => true) } #.wont_raise ArgumentError
+  end
+
+  it "should setex an element" do
+    lambda { @r.setex("key", 1, "value", :option => true) } #.wont_raise ArgumentError
+  end
+end

data/redis-store-json/test/redis/store/namespace_test.rb

@@ -0,0 +1,103 @@
+require 'test_helper'
+
+describe "Redis::Store::Namespace" do
+  def setup
+    @namespace = "theplaylist"
+    @store  = Redis::Store.new :namespace => @namespace, :strategy => false
+    @client = @store.instance_variable_get(:@client)
+    @rabbit = "bunny"
+  end
+
+  def teardown
+    @store.quit
+  end
+
+  it "only decorates instances that need to be namespaced" do
+    store  = Redis::Store.new
+    client = store.instance_variable_get(:@client)
+    client.expects(:call).with([:get, "rabbit"])
+    store.get("rabbit")
+  end
+
+  it "doesn't namespace a key which is already namespaced" do
+    @store.send(:interpolate, "#{@namespace}:rabbit").must_equal("#{@namespace}:rabbit")
+  end
+
+  it "should only delete namespaced keys" do
+    other_store = Redis::Store.new
+
+    other_store.set 'abc', 'cba'
+    @store.set 'def', 'fed'
+
+    @store.flushdb
+    @store.get('def').must_equal(nil)
+    other_store.get('abc').must_equal('cba')
+  end
+
+  it "should not try to delete missing namespaced keys" do
+    empty_store = Redis::Store.new :namespace => 'empty'
+    empty_store.flushdb
+    empty_store.keys.must_be_empty
+  end
+
+  it "namespaces get"
+  it "namespaces set"
+  it "namespaces setnx"
+  it "namespaces del with single key"
+  it "namespaces del with multiple keys"
+  it "namespaces keys"
+  it "namespaces exists"
+  it "namespaces incrby"
+  it "namespaces decrby"
+  it "namespaces mget"
+
+  # it "should namespace get" do
+  #   @client.expects(:call).with([:get, "#{@namespace}:rabbit"]).once
+  #   @store.get("rabbit")
+  # end
+  #
+  # it "should namespace set" do
+  #   @client.should_receive(:call).with([:set, "#{@namespace}:rabbit", @rabbit])
+  #   @store.set "rabbit", @rabbit
+  # end
+  #
+  # it "should namespace setnx" do
+  #   @client.should_receive(:call).with([:setnx, "#{@namespace}:rabbit", @rabbit])
+  #   @store.setnx "rabbit", @rabbit
+  # end
+  #
+  # it "should namespace del with single key" do
+  #   @client.should_receive(:call).with([:del, "#{@namespace}:rabbit"])
+  #   @store.del "rabbit"
+  # end
+  #
+  # it "should namespace del with multiple keys" do
+  #   @client.should_receive(:call).with([:del, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"])
+  #   @store.del "rabbit", "white_rabbit"
+  # end
+  #
+  # it "should namespace keys" do
+  #   @store.set "rabbit", @rabbit
+  #   @store.keys("rabb*").should == [ "rabbit" ]
+  # end
+  #
+  # it "should namespace exists" do
+  #   @client.should_receive(:call).with([:exists, "#{@namespace}:rabbit"])
+  #   @store.exists "rabbit"
+  # end
+  #
+  # it "should namespace incrby" do
+  #   @client.should_receive(:call).with([:incrby, "#{@namespace}:counter", 1])
+  #   @store.incrby "counter", 1
+  # end
+  #
+  # it "should namespace decrby" do
+  #   @client.should_receive(:call).with([:decrby, "#{@namespace}:counter", 1])
+  #   @store.decrby "counter", 1
+  # end
+  #
+  # it "should namespace mget" do
+  #   @client.should_receive(:call).with([:mget, "#{@namespace}:rabbit", "#{@namespace}:white_rabbit"])
+  #   @store.mget "rabbit", "white_rabbit"
+  # end
+end

data/redis-store-json/test/redis/store/strategy/json_session_test.rb

@@ -0,0 +1,160 @@
+require 'test_helper'
+
+# For faking rails flash objects retrieved from session
+module FakeActionDispatch
+  class Flash
+    class FlashHash < Hash
+    end
+  end
+end
+
+describe "Redis::Store::Strategy::JsonSession" do
+  def setup
+    @marshal_store = Redis::Store.new :strategy => :marshal
+    @store = Redis::Store.new :strategy => :json_session
+    @rabbit = {:name => "rabbit", :legs => 4}
+    @peter     = { :name => "Peter Cottontail",
+                   :race => @rabbit }
+    @bunnicula = { :name    => "Bunnicula",
+                   :race    => @rabbit,
+                   :friends => [@peter],
+                   :age     => 3.1,
+                   :alive   => true }
+    @store.set "rabbit", @bunnicula
+    @store.del "rabbit2"
+  end
+
+  def teardown
+    @store.quit
+  end
+
+  it "unmarshals on get" do
+    @store.get("rabbit").must_equal(@bunnicula)
+  end
+
+  it "marshals on set" do
+    @store.set "rabbit", @peter
+    @store.get("rabbit").must_equal(@peter)
+  end
+
+  it "doesn't unmarshal on get if raw option is true" do
+    race = @rabbit.to_json
+    @store.get("rabbit", :raw => true).must_equal(%({"name":"Bunnicula","race":#{race},"friends":[{"name":"Peter Cottontail","race":#{race}}],"age":3.1,"alive":true}))
+  end
+
+  it "doesn't marshal on set if raw option is true" do
+    race = @rabbit
+    @store.set "rabbit", @peter, :raw => true
+    @store.get("rabbit", :raw => true).must_equal(%({:name=>"Peter Cottontail", :race=>#{race.inspect}}))
+  end
+
+  it "doesn't set an object if already exist" do
+    @store.setnx "rabbit", @peter
+    @store.get("rabbit").must_equal(@bunnicula)
+  end
+
+  it "marshals on set unless exists" do
+    @store.setnx "rabbit2", @peter
+    @store.get("rabbit2").must_equal(@peter)
+  end
+
+  it "doesn't marshal on set unless exists if raw option is true" do
+    @store.setnx "rabbit2", @peter, :raw => true
+    race = @rabbit
+    @store.get("rabbit2", :raw => true).must_equal(%({:name=>"Peter Cottontail", :race=>#{race.inspect}}))
+  end
+
+  it "doesn't unmarshal on multi get" do
+    @store.set "rabbit2", @peter
+    rabbit, rabbit2 = @store.mget "rabbit", "rabbit2"
+    rabbit.must_equal(@bunnicula)
+    rabbit2.must_equal(@peter)
+  end
+
+  it "doesn't unmarshal on multi get if raw option is true" do
+    @store.set "rabbit", @bunnicula
+    @store.set "rabbit2", @peter
+    rabbit, rabbit2 = @store.mget "rabbit", "rabbit2", :raw => true
+    race = @rabbit.to_json
+    rabbit.must_equal(%({"name":"Bunnicula","race":#{race},"friends":[{"name":"Peter Cottontail","race":#{race}}],"age":3.1,"alive":true}))
+    rabbit2.must_equal(%({"name":"Peter Cottontail","race":#{race}}))
+  end
+
+  it "will throw an error if an object isn't supported" do
+    lambda{
+      @store.set "rabbit2", OpenStruct.new(foo:'bar')
+    }.must_raise Redis::Store::Strategy::JsonSession::SerializationError
+  end
+
+  it "is able to bring out data that is marshalled using Ruby" do
+    @marshal_store.set "rabbit", @peter
+    rabbit = @store.get "rabbit"
+    rabbit.must_equal(@peter)
+  end
+
+  it "can set a Set object" do
+    @store.set "set_object", Set.new([1,2])
+    set_object = @store.get("set_object")
+    set_object.must_equal([1,2])
+  end
+
+  describe "flash key value" do
+
+    before do
+      @flash_value = {:show_login => true }
+      @flash_data = {:flash => @flash_value}
+    end
+
+    describe "when ActionDispatch is available" do
+
+      before do
+        ActionDispatch = FakeActionDispatch
+        @store.class.send(:include, ActionDispatch)
+      end
+
+      it "returns a flash object instead of a hash" do
+        @store.set "flash", @flash_data
+        flash_store = @store.get "flash"
+        flash_hash = flash_store[:flash]
+        flash_hash.class.must_equal(FakeActionDispatch::Flash::FlashHash)
+        flash_hash.must_equal(@flash_value)
+      end
+
+    end
+
+    it "returns a hash" do
+      @store.set "flash", @flash_data
+      flash = @store.get "flash"
+      flash.must_equal(@flash_data)
+    end
+
+  end
+
+  describe "binary safety" do
+    before do
+      @utf8_key = [51339].pack("U*")
+      @ascii_string = [128].pack("C*")
+      @ascii_rabbit = {:name => "rabbit", :legs => 4, :ascii_string => @ascii_string}
+    end
+
+    it "gets and sets raw values" do
+      @store.set(@utf8_key, @ascii_string, :raw => true)
+      @store.get(@utf8_key, :raw => true).bytes.to_a.must_equal(@ascii_string.bytes.to_a)
+    end
+
+    it "marshals objects on setnx" do
+      @store.del(@utf8_key)
+      @store.setnx(@utf8_key, @ascii_rabbit)
+      retrievied_ascii_rabbit = @store.get(@utf8_key)
+      JSON.load(JSON.generate(retrievied_ascii_rabbit.delete(:ascii_string))).must_equal(@ascii_string)
+      @ascii_rabbit.delete(:ascii_string)
+      retrievied_ascii_rabbit.must_equal(@ascii_rabbit)
+    end
+
+    it "gets and sets raw values on setnx" do
+      @store.del(@utf8_key)
+      @store.setnx(@utf8_key, @ascii_string, :raw => true)
+      @store.get(@utf8_key, :raw => true).bytes.to_a.must_equal(@ascii_string.bytes.to_a)
+    end
+  end if defined?(Encoding)
+end

data/redis-store-json/test/redis/store/strategy/json_test.rb

@@ -0,0 +1,108 @@
+require 'test_helper'
+
+describe "Redis::Store::Strategy::Json" do
+  def setup
+    @store = Redis::Store.new :strategy => :json
+    @rabbit = OpenStruct.new :name => 'rabbit', :legs => 4
+    @peter     = { :name => "Peter Cottontail",
+                   :race => @rabbit }
+    @bunnicula = { :name    => "Bunnicula",
+                   :race    => @rabbit,
+                   :friends => [@peter],
+                   :age     => 3.1,
+                   :alive   => true }
+    @store.set "rabbit", @bunnicula
+    @store.del "rabbit2"
+  end
+
+  def teardown
+    @store.quit
+  end
+
+  it "unmarshals on get" do
+    @store.get("rabbit").must_equal(@bunnicula)
+  end
+
+  it "marshals on set" do
+    @store.set "rabbit", @peter
+    @store.get("rabbit").must_equal(@peter)
+  end
+
+  it "doesn't unmarshal on get if raw option is true" do
+    race = Marshal.dump(@rabbit).to_json
+    @store.get("rabbit", :raw => true).must_equal(%({"name":"Bunnicula","race":#{race},"friends":[{"name":"Peter Cottontail","race":#{race}}],"age":3.1,"alive":true}))
+  end
+
+  it "doesn't marshal on set if raw option is true" do
+    race = Marshal.dump(@rabbit)
+    @store.set "rabbit", @peter, :raw => true
+    @store.get("rabbit", :raw => true).must_equal(%({:name=>"Peter Cottontail", :race=>#{race.inspect}}))
+  end
+
+  it "doesn't set an object if already exist" do
+    @store.setnx "rabbit", @peter
+    @store.get("rabbit").must_equal(@bunnicula)
+  end
+
+  it "marshals on set unless exists" do
+    @store.setnx "rabbit2", @peter
+    @store.get("rabbit2").must_equal(@peter)
+  end
+
+  it "doesn't marshal on set unless exists if raw option is true" do
+    @store.setnx "rabbit2", @peter, :raw => true
+    race = Marshal.dump(@rabbit)
+    @store.get("rabbit2", :raw => true).must_equal(%({:name=>"Peter Cottontail", :race=>#{race.inspect}}))
+  end
+
+  it "marshals on set expire" do
+    @store.setex "rabbit2", 1, @peter
+    @store.get("rabbit2").must_equal(@peter)
+    sleep 2
+    @store.get("rabbit2").must_be_nil
+  end
+
+  it "doesn't unmarshal on multi get" do
+    @store.set "rabbit2", @peter
+    rabbit, rabbit2 = @store.mget "rabbit", "rabbit2"
+    rabbit.must_equal(@bunnicula)
+    rabbit2.must_equal(@peter)
+  end
+
+  it "doesn't unmarshal on multi get if raw option is true" do
+    @store.set "rabbit", @bunnicula
+    @store.set "rabbit2", @peter
+    rabbit, rabbit2 = @store.mget "rabbit", "rabbit2", :raw => true
+    race = Marshal.dump(@rabbit).to_json
+    rabbit.must_equal(%({"name":"Bunnicula","race":#{race},"friends":[{"name":"Peter Cottontail","race":#{race}}],"age":3.1,"alive":true}))
+    rabbit2.must_equal(%({"name":"Peter Cottontail","race":#{race}}))
+  end
+
+  describe "binary safety" do
+    before do
+      @utf8_key = [51339].pack("U*")
+      @ascii_string = [128].pack("C*")
+      @ascii_rabbit = OpenStruct.new(:name => @ascii_string)
+    end
+
+    it "marshals objects"
+      # @store.set(@utf8_key, @ascii_rabbit)
+      # @store.get(@utf8_key).must_equal(@ascii_rabbit)
+
+    it "gets and sets raw values" do
+      @store.set(@utf8_key, @ascii_string, :raw => true)
+      @store.get(@utf8_key, :raw => true).bytes.to_a.must_equal(@ascii_string.bytes.to_a)
+    end
+
+    it "marshals objects on setnx"
+      # @store.del(@utf8_key)
+      # @store.setnx(@utf8_key, @ascii_rabbit)
+      # @store.get(@utf8_key).must_equal(@ascii_rabbit)
+
+    it "gets and sets raw values on setnx" do
+      @store.del(@utf8_key)
+      @store.setnx(@utf8_key, @ascii_string, :raw => true)
+      @store.get(@utf8_key, :raw => true).bytes.to_a.must_equal(@ascii_string.bytes.to_a)
+    end
+  end if defined?(Encoding)
+end