mock_redis 0.36.0 → 0.37.0

data/spec/support/shared_examples/only_operates_on_hashes.rb

@@ -1,15 +0,0 @@
-shared_examples_for 'a hash-only command' do
-  it 'raises an error for non-hash values' do |example|
-    key = 'mock-redis-test:hash-only'
-
-    method = method_from_description(example)
-    args = args_for_method(method).unshift(key)
-
-    @redises.set(key, 1)
-    lambda do
-      @redises.send(method, *args)
-    end.should raise_error(RuntimeError)
-  end
-
-  it_should_behave_like 'does not remove empty strings on error'
-end

data/spec/support/shared_examples/only_operates_on_lists.rb

@@ -1,15 +0,0 @@
-shared_examples_for 'a list-only command' do
-  it 'raises an error for non-list values' do |example|
-    key = 'mock-redis-test:list-only'
-
-    method = method_from_description(example)
-    args = args_for_method(method).unshift(key)
-
-    @redises.set(key, 1)
-    lambda do
-      @redises.send(method, *args)
-    end.should raise_error(defined?(default_error) ? default_error : RuntimeError)
-  end
-
-  it_should_behave_like 'does not remove empty strings on error'
-end

data/spec/support/shared_examples/only_operates_on_sets.rb

@@ -1,15 +0,0 @@
-shared_examples_for 'a set-only command' do
-  it 'raises an error for non-set values' do |example|
-    key = 'mock-redis-test:set-only'
-
-    method = method_from_description(example)
-    args = args_for_method(method).unshift(key)
-
-    @redises.set(key, 1)
-    lambda do
-      @redises.send(method, *args)
-    end.should raise_error(RuntimeError)
-  end
-
-  it_should_behave_like 'does not remove empty strings on error'
-end

data/spec/support/shared_examples/only_operates_on_strings.rb

@@ -1,13 +0,0 @@
-shared_examples_for 'a string-only command' do
-  it 'raises an error for non-string values' do |example|
-    key = 'mock-redis-test:string-only-command'
-
-    method = method_from_description(example)
-    args = args_for_method(method).unshift(key)
-
-    @redises.lpush(key, 1)
-    lambda do
-      @redises.send(method, *args)
-    end.should raise_error(RuntimeError)
-  end
-end

data/spec/support/shared_examples/only_operates_on_zsets.rb

@@ -1,59 +0,0 @@
-shared_examples_for 'a zset-only command' do
-  it 'raises an error for non-zset values' do |example|
-    key = 'mock-redis-test:zset-only'
-
-    method = method_from_description(example)
-    args = args_for_method(method).unshift(key)
-
-    @redises.set(key, 1)
-    lambda do
-      @redises.send(method, *args)
-    end.should raise_error(RuntimeError)
-  end
-
-  it_should_behave_like 'does not remove empty strings on error'
-end
-
-shared_examples_for 'arg 1 is a score' do
-  before { @_arg_index = 1 }
-  it_should_behave_like 'arg N is a score'
-end
-
-shared_examples_for 'arg 2 is a score' do
-  before { @_arg_index = 2 }
-  it_should_behave_like 'arg N is a score'
-end
-
-shared_examples_for 'arg N is a score' do
-  before do |example|
-    key = 'mock-redis-test:zset-only'
-
-    @method = method_from_description(example)
-    @args = args_for_method(@method).unshift(key)
-  end
-
-  it 'is okay with positive ints' do
-    @args[@_arg_index] = 1
-    lambda { @redises.send(@method, *@args) }.should_not raise_error
-  end
-
-  it 'is okay with negative ints' do
-    @args[@_arg_index] = -1
-    lambda { @redises.send(@method, *@args) }.should_not raise_error
-  end
-
-  it 'is okay with positive floats' do
-    @args[@_arg_index] = 1.5
-    lambda { @redises.send(@method, *@args) }.should_not raise_error
-  end
-
-  it 'is okay with negative floats' do
-    @args[@_arg_index] = -1.5
-    lambda { @redises.send(@method, *@args) }.should_not raise_error
-  end
-
-  it 'rejects non-numbers' do
-    @args[@_arg_index] = 'foo'
-    lambda { @redises.send(@method, *@args) }.should raise_error(RuntimeError)
-  end
-end

data/spec/support/shared_examples/sorts_enumerables.rb

@@ -1,56 +0,0 @@
-shared_examples_for 'a sortable' do
-  it 'returns empty array on nil' do
-    @redises.sort(nil).should == []
-  end
-
-  context 'ordering' do
-    it 'orders ascending by default' do
-      @redises.sort(@key).should == %w[1 2]
-    end
-
-    it 'orders by descending when specified' do
-      @redises.sort(@key, :order => 'DESC').should == %w[2 1]
-    end
-  end
-
-  context 'projections' do
-    it 'projects element when :get is "#"' do
-      @redises.sort(@key, :get => '#').should == %w[1 2]
-    end
-
-    it 'projects through a key pattern' do
-      @redises.sort(@key, :get => 'mock-redis-test:values_*').should == %w[a b]
-    end
-
-    it 'projects through a key pattern and reflects element' do
-      @redises.sort(@key, :get => ['#', 'mock-redis-test:values_*']).should == [%w[1 a], %w[2 b]]
-    end
-
-    it 'projects through a hash key pattern' do
-      @redises.sort(@key, :get => 'mock-redis-test:hash_*->key').should == %w[x y]
-    end
-  end
-
-  context 'weights' do
-    it 'weights by projecting through a key pattern' do
-      @redises.sort(@key, :by => 'mock-redis-test:weight_*').should == %w[2 1]
-    end
-
-    it 'weights by projecting through a key pattern and a specific order' do
-      @redises.sort(@key, :order => 'DESC', :by => 'mock-redis-test:weight_*').should == %w[1 2]
-    end
-  end
-
-  context 'limit' do
-    it 'only returns requested window in the enumerable' do
-      @redises.sort(@key, :limit => [0, 1]).should == ['1']
-    end
-  end
-
-  context 'store' do
-    it 'stores into another key' do
-      @redises.sort(@key, :store => 'mock-redis-test:some_bucket').should == 2
-      @redises.lrange('mock-redis-test:some_bucket', 0, -1).should == %w[1 2]
-    end
-  end
-end

data/spec/transactions_spec.rb

@@ -1,163 +0,0 @@
-require 'spec_helper'
-
-describe 'transactions (multi/exec/discard)' do
-  before(:each) do
-    @redises.discard rescue nil
-  end
-
-  context '#multi' do
-    it "responds with 'OK'" do
-      @redises.multi.should == 'OK'
-    end
-
-    it 'does not permit nesting' do
-      @redises.multi
-      lambda do
-        @redises.multi
-      end.should raise_error(Redis::CommandError, 'ERR MULTI calls can not be nested')
-    end
-
-    it 'cleans state of transaction wrapper if exception occurs during transaction' do
-      lambda do
-        @redises.mock.multi do |_r|
-          raise "i'm a command that fails"
-        end
-      end.should raise_error(RuntimeError)
-
-      # before the fix this used to raised a #<RuntimeError: ERR MULTI calls can not be nested>
-      lambda do
-        @redises.mock.multi do |r|
-          # do stuff that succeed
-          r.set(nil, 'string')
-        end
-      end.should_not raise_error
-    end
-  end
-
-  context '#blocks' do
-    it 'implicitly runs exec when finished' do
-      @redises.set('counter', 5)
-      @redises.multi do |r|
-        r.set('test', 1)
-        r.incr('counter')
-      end
-      @redises.get('counter').should eq '6'
-      @redises.get('test').should eq '1'
-    end
-
-    it 'permits nesting via blocks' do
-      # Have to use only the mock here. redis-rb has a bug in it where
-      # nested #multi calls raise NoMethodError because it gets a nil
-      # where it's not expecting one.
-      @redises.mock.multi do |r|
-        lambda do
-          r.multi {}
-        end.should_not raise_error
-      end
-    end
-
-    it 'allows pipelined calls within multi blocks' do
-      @redises.set('counter', 5)
-      @redises.multi do |r|
-        r.pipelined do |pr|
-          pr.set('test', 1)
-          pr.incr('counter')
-        end
-      end
-      @redises.get('counter').should eq '6'
-      @redises.get('test').should eq '1'
-    end
-
-    it 'allows blocks within multi blocks' do
-      @redises.set('foo', 'bar')
-      @redises.set('fuu', 'baz')
-
-      result = nil
-
-      @redises.multi do |r|
-        result = r.mget('foo', 'fuu') { |reply| reply.map(&:upcase) }
-        r.del('foo', 'fuu')
-      end
-
-      result.value.should eq %w[BAR BAZ]
-      @redises.get('foo').should eq nil
-      @redises.get('fuu').should eq nil
-    end
-  end
-
-  context '#discard' do
-    it "responds with 'OK' after #multi" do
-      @redises.multi
-      @redises.discard.should eq 'OK'
-    end
-
-    it "can't be run outside of #multi/#exec" do
-      lambda do
-        @redises.discard
-      end.should raise_error(Redis::CommandError)
-    end
-  end
-
-  context '#exec' do
-    it 'raises an error outside of #multi' do
-      lambda do
-        @redises.exec.should raise_error
-      end
-    end
-  end
-
-  context 'saving up commands for later' do
-    before(:each) do
-      @redises.multi
-      @string = 'mock-redis-test:string'
-      @list = 'mock-redis-test:list'
-    end
-
-    it "makes commands respond with 'QUEUED'" do
-      @redises.set(@string, 'string').should eq 'QUEUED'
-      @redises.lpush(@list, 'list').should eq 'QUEUED'
-    end
-
-    it "gives you the commands' responses when you call #exec" do
-      @redises.set(@string, 'string')
-      @redises.lpush(@list, 'list')
-      @redises.lpush(@list, 'list')
-
-      @redises.exec.should eq ['OK', 1, 2]
-    end
-
-    it "does not raise exceptions, but rather puts them in #exec's response" do
-      @redises.set(@string, 'string')
-      @redises.lpush(@string, 'oops!')
-      @redises.lpush(@list, 'list')
-
-      responses = @redises.exec
-      responses[0].should eq 'OK'
-      responses[1].should be_a(Redis::CommandError)
-      responses[2].should eq 1
-    end
-  end
-
-  context 'saving commands with multi block' do
-    before(:each) do
-      @string = 'mock-redis-test:string'
-      @list = 'mock-redis-test:list'
-    end
-
-    it 'commands return response after exec is called' do
-      set_response = nil
-      lpush_response = nil
-      second_lpush_response = nil
-
-      @redises.multi do |mult|
-        set_response = mult.set(@string, 'string')
-        lpush_response = mult.lpush(@list, 'list')
-        second_lpush_response = mult.lpush(@list, 'list')
-      end
-
-      set_response.value.should eq 'OK'
-      lpush_response.value.should eq 1
-      second_lpush_response.value.should eq 2
-    end
-  end
-end