redis-store 1.0.0.1 → 1.1.0.rc

data/spec/redis/factory_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-describe "Redis::Factory" do
-  describe ".create" do
-    context "when not given any arguments" do
-      it "should instantiate a Redis::Store store" do
-        store = Redis::Factory.create
-        store.should be_kind_of(Redis::Store)
-        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
-      end
-    end
-
-    context "when given a Hash" do
-      it "should allow to specify host" do
-        store = Redis::Factory.create :host => "localhost"
-        store.to_s.should == "Redis Client connected to localhost:6379 against DB 0"
-      end
-
-      it "should allow to specify port" do
-        store = Redis::Factory.create :host => "localhost", :port => 6380
-        store.to_s.should == "Redis Client connected to localhost:6380 against DB 0"
-      end
-
-      it "should allow to specify db" do
-        store = Redis::Factory.create :host => "localhost", :port => 6380, :db => 13
-        store.to_s.should == "Redis Client connected to localhost:6380 against DB 13"
-      end
-
-      it "should allow to specify namespace" do
-        store = Redis::Factory.create :namespace => "theplaylist"
-        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
-      end
-
-      it "should allow to specify key_prefix as namespace" do
-        store = Redis::Factory.create :key_prefix => "theplaylist"
-        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
-      end
-
-      it "should allow to specify marshalling" do
-        store = Redis::Factory.create :marshalling => false
-        store.instance_variable_get(:@marshalling).should be_false
-      end
-
-      it "should allow to specify password" do
-        store = Redis::Factory.create :password => "secret"
-        store.instance_variable_get(:@client).password.should == "secret"
-      end
-
-      it "should instantiate a Redis::DistributedStore store" do
-        store = Redis::Factory.create(
-          {:host => "localhost", :port => 6379},
-          {:host => "localhost", :port => 6380}
-        )
-        store.should be_kind_of(Redis::DistributedStore)
-        store.nodes.map {|node| node.to_s}.should == [
-          "Redis Client connected to localhost:6379 against DB 0",
-          "Redis Client connected to localhost:6380 against DB 0",
-        ]
-      end
-    end
-
-    context "when given a String" do
-      it "should allow to specify host" do
-        store = Redis::Factory.create "redis://127.0.0.1"
-        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0"
-      end
-
-      it "should allow to specify port" do
-        store = Redis::Factory.create "redis://127.0.0.1:6380"
-        store.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 0"
-      end
-
-      it "should allow to specify db" do
-        store = Redis::Factory.create "redis://127.0.0.1:6380/13"
-        store.to_s.should == "Redis Client connected to 127.0.0.1:6380 against DB 13"
-      end
-
-      it "should allow to specify namespace" do
-        store = Redis::Factory.create "redis://127.0.0.1:6379/0/theplaylist"
-        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
-      end
-
-      it "should allow to specify scheme" do
-        store = Redis::Factory.create "redis://127.0.0.1:6379/0/theplaylist"
-        store.to_s.should == "Redis Client connected to 127.0.0.1:6379 against DB 0 with namespace theplaylist"
-      end
-
-      it "should allow to specify password" do
-        store = Redis::Factory.create "redis://:secret@127.0.0.1:6379/0/theplaylist"
-        store.instance_variable_get(:@client).password.should == "secret"
-      end
-
-      it "should allow to specify password without scheme" do
-        suppress_warnings do
-          store = Redis::Factory.create ":secret@127.0.0.1:6379/0/theplaylist"
-          store.instance_variable_get(:@client).password.should == "secret"
-        end
-      end
-
-      it "should instantiate a Redis::DistributedStore store" do
-        store = Redis::Factory.create "redis://127.0.0.1:6379", "redis://127.0.0.1:6380"
-        store.should be_kind_of(Redis::DistributedStore)
-        store.nodes.map {|node| node.to_s}.should == [
-          "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/spec/redis/store/interface_spec.rb

@@ -1,23 +0,0 @@
-require 'spec_helper'
-
-class InterfacedRedis < Redis
-  include Redis::Store::Interface
-end
-
-describe "Redis::Store::Interface" do
-  before :each do
-    @r = InterfacedRedis.new
-  end
-
-  it "should get an element" do
-    lambda { @r.get("key", :option => true) }.should_not raise_error
-  end
-
-  it "should set an element" do
-    lambda { @r.set("key", "value", :option => true) }.should_not raise_error
-  end
-
-  it "should setnx an element" do
-    lambda { @r.setnx("key", "value", :option => true) }.should_not raise_error
-  end
-end

data/spec/redis/store/marshalling_spec.rb

@@ -1,119 +0,0 @@
-require 'spec_helper'
-
-describe "Redis::Marshalling" do
-  before(:each) do
-    @store = Redis::Store.new :marshalling => true
-    @rabbit = OpenStruct.new :name => "bunny"
-    @white_rabbit = OpenStruct.new :color => "white"
-    @store.set "rabbit", @rabbit
-    @store.del "rabbit2"
-  end
-
-  after :each do
-    @store.quit
-  end
-
-  it "should unmarshal an object on get" do
-    @store.get("rabbit").should === @rabbit
-  end
-
-  it "should marshal object on set" do
-    @store.set "rabbit", @white_rabbit
-    @store.get("rabbit").should === @white_rabbit
-  end
-
-  if RUBY_VERSION.match /1\.9/
-    it "should not unmarshal object on get if raw option is true" do
-      @store.get("rabbit", :raw => true).should == "\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF"
-    end
-  else
-    it "should not unmarshal object on get if raw option is true" do
-      @store.get("rabbit", :raw => true).should == "\004\bU:\017OpenStruct{\006:\tname\"\nbunny"
-    end
-  end
-
-  it "should not marshal object on set if raw option is true" do
-    @store.set "rabbit", @white_rabbit, :raw => true
-    @store.get("rabbit", :raw => true).should == %(#<OpenStruct color="white">)
-  end
-
-  it "should not unmarshal object if getting an empty string" do
-    @store.set "empty_string", ""
-    lambda { @store.get("empty_string").should == "" }.should_not raise_error
-  end
-
-  it "should not set an object if already exist" do
-    @store.setnx "rabbit", @white_rabbit
-    @store.get("rabbit").should === @rabbit
-  end
-
-  it "should marshal object on set_unless_exists" do
-    @store.setnx "rabbit2", @white_rabbit
-    @store.get("rabbit2").should === @white_rabbit
-  end
-
-  it "should not marshal object on set_unless_exists if raw option is true" do
-    @store.setnx "rabbit2", @white_rabbit, :raw => true
-    @store.get("rabbit2", :raw => true).should == %(#<OpenStruct color="white">)
-  end
-
-  it "should unmarshal object(s) on multi get" do
-    @store.set "rabbit2", @white_rabbit
-    rabbit, rabbit2 = @store.mget "rabbit", "rabbit2"
-    rabbit.should  == @rabbit
-    rabbit2.should == @white_rabbit
-  end
-
-  if RUBY_VERSION.match /1\.9/
-    it "should not unmarshal object(s) on multi get if raw option is true" do
-      @store.set "rabbit2", @white_rabbit
-      rabbit, rabbit2 = @store.mget "rabbit", "rabbit2", :raw => true
-      rabbit.should  == "\x04\bU:\x0FOpenStruct{\x06:\tnameI\"\nbunny\x06:\x06EF"
-      rabbit2.should == "\x04\bU:\x0FOpenStruct{\x06:\ncolorI\"\nwhite\x06:\x06EF"
-    end
-  else
-    it "should not unmarshal object(s) on multi get if raw option is true" do
-      @store.set "rabbit2", @white_rabbit
-      rabbit, rabbit2 = @store.mget "rabbit", "rabbit2", :raw => true
-      rabbit.should  == "\004\bU:\017OpenStruct{\006:\tname\"\nbunny"
-      rabbit2.should == "\004\bU:\017OpenStruct{\006:\ncolor\"\nwhite"
-    end
-  end
-
-  describe "binary safety" do
-    it "should marshal objects" do
-      utf8_key = [51339].pack("U*")
-      ascii_rabbit = OpenStruct.new(:name => [128].pack("C*"))
-
-      @store.set(utf8_key, ascii_rabbit)
-      @store.get(utf8_key).should === ascii_rabbit
-    end
-
-    it "should get and set raw values" do
-      utf8_key = [51339].pack("U*")
-      ascii_string = [128].pack("C*")
-
-      @store.set(utf8_key, ascii_string, :raw => true)
-      @store.get(utf8_key, :raw => true).bytes.to_a === ascii_string.bytes.to_a
-    end
-
-    it "should marshal objects on setnx" do
-      utf8_key = [51339].pack("U*")
-      ascii_rabbit = OpenStruct.new(:name => [128].pack("C*"))
-
-      @store.del(utf8_key)
-      @store.setnx(utf8_key, ascii_rabbit)
-      @store.get(utf8_key).should === ascii_rabbit
-    end
-
-    it "should get and set raw values on setnx" do
-      utf8_key = [51339].pack("U*")
-      ascii_string = [128].pack("C*")
-
-      @store.del(utf8_key)
-      @store.setnx(utf8_key, ascii_string, :raw => true)
-      @store.get(utf8_key, :raw => true).bytes.to_a === ascii_string.bytes.to_a
-    end
-  end if defined?(Encoding)
-end
-

data/spec/redis/store/namespace_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe "Redis::Store::Namespace" do
-  before :each do
-    @namespace = "theplaylist"
-    @store  = Redis::Store.new :namespace => @namespace, :marshalling => false # TODO remove mashalling option
-    @client = @store.instance_variable_get(:@client)
-    @rabbit = "bunny"
-  end
-
-  after :each do
-    @store.should_receive(:quit) # stupid rspec, meh!
-    @store.quit
-  end
-
-  it "should only decorate instances that needs to be namespaced" do
-    @store = Redis::Store.new
-    client = @store.instance_variable_get(:@client)
-    client.should_receive(:call).with([:get, "rabbit"])
-    @store.get("rabbit")
-  end
-
-  it "should not namespace a key which is already namespaced" do
-    @store.send(:interpolate, "#{@namespace}:rabbit").should == "#{@namespace}:rabbit"
-  end
-
-  it "should namespace get" do
-    @client.should_receive(:call).with([:get, "#{@namespace}:rabbit"])
-    @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/spec/redis/store/version_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Redis::Store::VERSION do
-  it "should describe Redis::Store version" do
-    Redis::Store::VERSION::STRING.should == "1.0.0.1"
-  end
-end

data/spec/redis/store_spec.rb

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-describe "Redis::Store" do
-  before :each do
-    @store = Redis::Store.new
-  end
-
-  it "should force reconnection" do
-    client = @store.instance_variable_get(:@client)
-    client.should_receive(:reconnect)
-    @store.reconnect
-  end
-end

data/spec/spec_helper.rb

@@ -1,43 +0,0 @@
-$:.unshift(File.expand_path(File.join(File.dirname(__FILE__), "/../lib")))
-ARGV << "-b"
-require "rubygems"
-require "bundler"
-Bundler.setup
-require "methopara" if RUBY_VERSION.match /1\.9/
-require "ostruct"
-require "spec"
-require "spec/autorun"
-require "redis"
-require "merb"
-require "i18n"
-require "rack/cache"
-require "rack/cache/metastore"
-require "rack/cache/entitystore"
-require "redis-store"
-require "active_support"
-begin
-  require "action_controller/session/abstract_store" # Rails 2.3.x
-rescue LoadError
-  require "action_dispatch/middleware/session/abstract_store" # Rails 3.x
-  module ::Rails
-    module VERSION
-      MAJOR = 3
-    end
-  end
-end
-require "active_support/cache/redis_store"
-require "action_controller/session/redis_session_store"
-require "cache/sinatra/redis_store"
-
-$DEBUG = ENV["DEBUG"] === "true"
-
-# http://mentalized.net/journal/2010/04/02/suppress_warnings_from_ruby/
-module Kernel
-  def suppress_warnings
-    original_verbosity = $VERBOSE
-    $VERBOSE = nil
-    result = yield
-    $VERBOSE = original_verbosity
-    return result
-  end
-end

data/tasks/redis.tasks.rb

@@ -1,235 +0,0 @@
-# inspired by old Rake tasks from redis-rb
-require 'rake'
-require 'fileutils'
-require 'open-uri'
-
-class RedisRunner
-  def self.port
-    6379
-  end
-
-  def self.redisdir
-    @@redisdir ||= File.expand_path File.join(File.dirname(__FILE__), '..', 'vendor', 'redis')
-  end
-
-  def self.redisconfdir
-    '/etc/redis.conf'
-  end
-
-  def self.dtach_socket
-    '/tmp/redis.dtach'
-  end
-
-  # Just check for existance of dtach socket
-  def self.running?
-    File.exists? dtach_socket
-  end
-
-  def self.start
-    puts 'Detach with Ctrl+\  Re-attach with rake redis:attach'
-    sleep 3
-    exec "dtach -A #{dtach_socket} redis-server #{redisconfdir}"
-  end
-
-  def self.start_detached
-    system "dtach -n #{dtach_socket} redis-server #{redisconfdir}"
-  end
-
-  def self.attach
-    exec "dtach -a #{dtach_socket}"
-  end
-
-  def self.stop
-    system %(redis-cli -p #{port} SHUTDOWN)
-  end
-end
-
-class MainRedisRunner < RedisRunner
-  def self.redisconfdir
-    File.expand_path(File.dirname(__FILE__) + "/../spec/config/redis.conf")
-  end
-end
-
-class NodeOneRedisRunner < RedisRunner
-  def self.redisconfdir
-    File.expand_path(File.dirname(__FILE__) + "/../spec/config/node-one.conf")
-  end
-
-  def self.dtach_socket
-    "/tmp/redis-node-one.dtach"
-  end
-
-  def self.port
-    6380
-  end
-end
-
-class NodeTwoRedisRunner < RedisRunner
-  def self.redisconfdir
-    File.expand_path(File.dirname(__FILE__) + "/../spec/config/node-two.conf")
-  end
-
-  def self.dtach_socket
-    "/tmp/redis-node-two.dtach"
-  end
-
-  def self.port
-    6381
-  end
-end
-
-class RedisReplicationRunner
-  def self.runners
-    [ MainRedisRunner, NodeOneRedisRunner, NodeTwoRedisRunner ]
-  end
-
-  def self.start_detached
-    runners.each do |runner|
-      runner.start_detached
-    end
-  end
-
-  def self.stop
-    runners.each do |runner|
-      runner.stop
-    end
-  end
-end
-
-namespace :redis do
-  desc 'About redis'
-  task :about do
-    puts "\nSee http://code.google.com/p/redis/ for information about redis.\n\n"
-  end
-
-  desc 'Start redis'
-  task :start => 'dtach:check' do
-    RedisRunner.start
-  end
-
-  desc 'Stop redis'
-  task :stop do
-    RedisRunner.stop
-  end
-
-  desc 'Restart redis'
-  task :restart do
-    RedisRunner.stop
-    RedisRunner.start
-  end
-
-  desc 'Attach to redis dtach socket'
-  task :attach do
-    RedisRunner.attach
-  end
-
-  desc 'Install the lastest verison of Redis from Github (requires git, duh)'
-  task :install => [ :about, :download, :make ] do
-    %w(redis-benchmark redis-cli redis-server).each do |bin|
-      if File.exist?(path = "#{RedisRunner.redisdir}/src/#{bin}")
-        sh "sudo cp #{path} /usr/bin/"
-      else
-        sh "sudo cp #{RedisRunner.redisdir}/#{bin} /usr/bin/"
-      end
-    end
-
-    puts "Installed redis-benchmark, redis-cli and redis-server to /usr/bin/"
-
-    sh "sudo cp #{RedisRunner.redisdir}/redis.conf /etc/"
-    puts "Installed redis.conf to /etc/ \n You should look at this file!"
-  end
-
-  task :make do
-    sh "cd #{RedisRunner.redisdir} && make clean"
-    sh "cd #{RedisRunner.redisdir} && make"
-  end
-
-  desc "Download package"
-  task :download do
-    require 'git'
-
-    sh "rm -rf #{RedisRunner.redisdir} && mkdir -p vendor && rm -rf redis"
-    Git.clone("git://github.com/antirez/redis.git", "redis")
-    sh "mv redis vendor"
-
-    commit = case ENV['VERSION']
-      when "1.3.12" then "26ef09a83526e5099bce"
-      when "2.2.8"  then "ec279203df0bc6ddc981"
-    end
-
-    arguments = commit.nil? ? "pull origin master" : "reset --hard #{commit}"
-    sh "cd #{RedisRunner.redisdir} && git #{arguments}"
-  end
-
-  desc "Open an IRb session"
-  task :console do
-    RedisRunner.start_detached
-    system "bundle exec irb -I lib -I extra -r redis-store.rb"
-    RedisRunner.stop
-  end
-
-  namespace :replication do
-    desc "Starts redis replication servers"
-    task :start => 'dtach:check' do
-      result = RedisReplicationRunner.start_detached
-      raise("Could not start redis-server, aborting.") unless result
-    end
-
-    desc "Stops redis replication servers"
-    task :stop do
-      RedisReplicationRunner.stop
-    end
-
-    desc "Open an IRb session with the master/slave replication"
-    task :console do
-      RedisReplicationRunner.start_detached
-      system "bundle exec irb -I lib -I extra -r redis-store.rb"
-      RedisReplicationRunner.stop
-    end
-  end
-end
-
-namespace :dtach do
-  desc 'About dtach'
-  task :about do
-    puts "\nSee http://dtach.sourceforge.net/ for information about dtach.\n\n"
-  end
-
-  desc 'Check that dtach is available'
-  task :check do
-    if !ENV['TRAVIS'] && !system('which dtach')
-      raise "dtach is not installed. Install it manually or run 'rake dtach:install'"
-    end
-  end
-
-  desc 'Install dtach 0.8 from source'
-  task :install => [:about] do
-
-    Dir.chdir('/tmp/')
-    unless File.exists?('/tmp/dtach-0.8.tar.gz')
-      require 'net/http'
-
-      url = 'http://downloads.sourceforge.net/project/dtach/dtach/0.8/dtach-0.8.tar.gz'
-      open('/tmp/dtach-0.8.tar.gz', 'wb') do |file| file.write(open(url).read) end
-    end
-
-    unless File.directory?('/tmp/dtach-0.8')
-      system('tar xzf dtach-0.8.tar.gz')
-    end
-
-    Dir.chdir('/tmp/dtach-0.8/')
-    sh 'cd /tmp/dtach-0.8/ && ./configure && make'
-    sh 'sudo cp /tmp/dtach-0.8/dtach /usr/bin/'
-
-    puts 'Dtach successfully installed to /usr/bin.'
-  end
-end
-
-def invoke_with_redis_replication(task_name)
-  begin
-    Rake::Task["redis:replication:start"].invoke
-    Rake::Task[task_name].invoke
-  ensure
-    Rake::Task["redis:replication:stop"].invoke
-  end
-end