swagger 1.4.0 → 1.4.1

data/lib/swagger/swallow.rb

@@ -0,0 +1,14 @@
+module Swagger
+  module Swallow
+
+    def swallow(method, return_value = nil)
+      define_method(method) do |*args|
+        if defined?(LOGGER)
+          LOGGER.write "Swagger::Redis swallowed #{method} with the following arguments #{args.inspect}"
+        end
+        return_value
+      end
+    end
+
+  end
+end

data/lib/swagger/version.rb

@@ -0,0 +1,7 @@
+module Swagger
+  module_function
+
+  def version
+    '1.4.1'
+  end
+end

data/spec/resque_extension_spec.rb

@@ -1,12 +1,11 @@
-require 'spec/spec_helper'
+require 'spec_helper'
 
 describe 'Resque' do
-  
-  it 'swaps redis implementation with impersonator' do
-    Resque.redis.should be_a(RedisImpersonator)
-  end  
-  
+  it 'swaps redis implementation with Swagger::Redis' do
+    Resque.redis.should be_a(Swagger::Redis)
+  end
+
   it 'can connect to the database' do
     Resque.should.respond_to?(:connect_to_database)
   end
-end
+end

data/spec/spec_helper.rb

@@ -1,31 +1,34 @@
 require 'rubygems'
-require 'resque'
+require 'bundler'
+Bundler.setup
 
-$LOAD_PATH.unshift(File.dirname(__FILE__))
-$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'resque'
 require 'swagger'
-require 'spec'
-require 'spec/autorun'
 
-Spec::Runner.configure do |config|
+Dir['./spec/support/*.rb'].map {|f| require f }
 
-  config.prepend_before :each do
-    ResqueValue.delete_all
-  end  
-  
+RSpec.configure do |config|
+  config.color_enabled = true
+  config.before { ResqueValue.delete_all }
 end
 
 Resque.swagger!
 
 ActiveRecord::Base.establish_connection('adapter' => 'sqlite3', 'database' => 'test.db')
 
-ActiveRecord::Base.connection.drop_table :resque_values rescue puts "unable to drop resque_values, probably because it has not been created yet"
+begin
+  ActiveRecord::Base.connection.drop_table :resque_values
+rescue
+  puts "unable to drop resque_values, probably because it has not been created yet"
+end
+
 ActiveRecord::Base.connection.create_table :resque_values do |table|
   table.column :key,      :string
   table.column :key_type, :string
-  table.column :value, :text
+  table.column :score,    :integer
+  table.column :value,    :text
+  table.timestamps
 end
 
 ActiveRecord::Base.connection.add_index :resque_values, :key
-ActiveRecord::Base.connection.add_index :resque_values, [:key, :key_type]
-
+ActiveRecord::Base.connection.add_index :resque_values, [:key, :key_type]

data/spec/support/helpers.rb

@@ -0,0 +1,7 @@
+def expect_count_to_change(count = 1, &block)
+  expect { block.call }.to change(ResqueValue, :count).by(count)
+end
+
+def expect_count_to_not_change(&block)
+  expect { block.call }.to_not change(ResqueValue, :count)
+end

data/spec/swagger/commands/sorted_sets_spec.rb

@@ -0,0 +1,175 @@
+require 'spec_helper'
+
+module Swagger
+  describe Redis, 'sorted sets' do
+
+    describe '#zadd' do
+      it 'adds a new record' do
+        expect_count_to_change { add_record }
+      end
+
+      it 'sets the record attributes correctly' do
+        record = add_record
+        record.key.should eq('key')
+        record.score.should eq(100)
+        record.value.should eq('value')
+      end
+
+      context 'with a record added' do
+        let!(:record) { add_record }
+
+        it 'does not add a new record if the values are the same' do
+          expect_count_to_not_change { add_record }
+        end
+
+        it "updates the record's score if it's different" do
+          add_record(:score => 500)
+          record.reload.score.should eq(500)
+        end
+
+        it 'adds another record if the key is different' do
+          expect_count_to_change { add_record(:key => 'key2') }
+        end
+
+        it 'adds another record if the value is different' do
+          expect_count_to_change { add_record(:value => 'value2') }
+        end
+      end
+    end
+
+    describe '#zrem' do
+      context 'with a record added' do
+        let!(:record) { add_record(:key => 'k', :value => 'v') }
+
+        it 'deletes the record' do
+          expect_count_to_change(-1) { subject.zrem(:k, 'v') }
+        end
+      end
+    end
+
+    describe '#zcard' do
+      context 'with 3 records added' do
+        before do
+          add_record(:score => '1', :value => '#1')
+          add_record(:score => '3', :value => '#3')
+          add_record(:score => '2', :value => '#2')
+        end
+
+        specify { subject.zcard(:key).should eq(3) }
+      end
+    end
+
+    describe '#zrange' do
+      context 'with 5 records added' do
+        before do
+          add_record(:score => 1, :value => '#1')
+          add_record(:score => 3, :value => '#3')
+          add_record(:score => 2, :value => '#2')
+          add_record(:score => 5, :value => '#5')
+          add_record(:score => 4, :value => '#4')
+        end
+
+        context 'given the entire range' do
+          let(:values) { subject.zrange(:key, 0, -1) }
+
+          specify { values.should have(5).values }
+
+          it 'sorts the values by score' do
+            values[0].should eq('#1')
+            values[1].should eq('#2')
+            values[2].should eq('#3')
+            values[3].should eq('#4')
+            values[4].should eq('#5')
+          end
+        end
+
+        context 'given a range of 1 to 3' do
+          let(:values) { subject.zrange(:key, 1, 3) }
+
+          specify { values.should have(3).values }
+
+          it 'sorts the values by score' do
+            values[0].should eql('#2')
+            values[1].should eql('#3')
+            values[2].should eql('#4')
+          end
+        end
+      end
+    end
+
+    describe '#zrangebyscore' do
+      context 'with 5 records added' do
+        before do
+          add_record(:score => 1, :value => '#1')
+          add_record(:score => 3, :value => '#3')
+          add_record(:score => 2, :value => '#2')
+          add_record(:score => 5, :value => '#5')
+          add_record(:score => 4, :value => '#4')
+        end
+
+        context 'given the entire range' do
+          let(:values) { subject.zrangebyscore(:key, 1, 5) }
+
+          specify { values.should have(5).values }
+
+          it 'sorts the values by score' do
+            values[0].should eq('#1')
+            values[1].should eq('#2')
+            values[2].should eq('#3')
+            values[3].should eq('#4')
+            values[4].should eq('#5')
+          end
+
+          context 'and :limit option' do
+            context 'with 1 offset and 3 count' do
+              let(:values) do
+                subject.zrangebyscore(:key, 1, 5, :limit => [1, 3])
+              end
+
+              specify { values.should have(3).values }
+
+              it 'sorts the values by score' do
+                values[0].should eq('#2')
+                values[1].should eq('#3')
+                values[2].should eq('#4')
+              end
+            end
+          end
+        end
+
+        context 'given -inf (lowest score) and 3' do
+          let(:values) { subject.zrangebyscore(:key, '-inf', 3) }
+
+          specify { values.should have(3).values }
+
+          it 'sorts the values by score' do
+            values[0].should eq('#1')
+            values[1].should eq('#2')
+            values[2].should eq('#3')
+          end
+        end
+
+        context 'given 3 and +inf (highest score)' do
+          let(:values) { subject.zrangebyscore(:key, 3, '+inf') }
+
+          specify { values.should have(3).values }
+
+          it 'sorts the values by score' do
+            values[0].should eq('#3')
+            values[1].should eq('#4')
+            values[2].should eq('#5')
+          end
+        end
+      end
+    end
+
+    def add_record(args = {})
+      key   = args.fetch(:key)   { 'key' }
+      score = args.fetch(:score) { 100 }
+      value = args.fetch(:value) { 'value' }
+
+      subject.zadd(key, score, value)
+    end
+
+  end
+end

data/spec/swagger/commands/strings_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+module Swagger
+  describe Redis, 'strings' do
+
+    describe '#setnx' do
+      it 'adds a new record' do
+        expect_count_to_change { add_record }
+      end
+
+      it 'sets the record attributes correctly' do
+        record = add_record
+        record.key.should eq('key')
+        record.value.should eq('value')
+      end
+
+      context 'with a record added' do
+        let!(:record) { add_record }
+
+        it 'does not add a new record if the values are the same' do
+          expect_count_to_not_change { add_record }
+        end
+
+        it "does not update the record's value if it's different" do
+          add_record(:value => 'foo')
+          record.reload.value.should eq('value')
+        end
+      end
+    end
+
+    describe '#incr' do
+      let!(:record) { add_record(:value => '1') }
+
+      it "increments a record's value by one" do
+        subject.incr('key')
+        record.reload.value.should eq('2')
+      end
+    end
+
+    describe '#decr' do
+      let!(:record) { add_record(:value => '1') }
+
+      it "decrements a record's value by one" do
+        subject.decr('key')
+        record.reload.value.should eq('0')
+      end
+    end
+
+    def add_record(args = {})
+      key   = args.fetch(:key)   { 'key' }
+      value = args.fetch(:value) { 'value' }
+
+      subject.setnx(key, value)
+      ResqueValue.find_by_key_and_value(key, value)
+    end
+
+  end
+end

data/spec/swagger/redis_spec.rb

@@ -0,0 +1,171 @@
+require 'spec_helper'
+
+module Swagger
+  describe Redis do
+    it 'responds to info' do
+      subject.info.should_not be_nil
+    end
+
+    it 'swallows calls to namespace' do
+      lambda{subject.namespace = 'value'}.should_not raise_error
+    end
+
+    describe 'manipulating key values' do
+      it 'it can get key values' do
+        subject.set('key', 'value').should == 'value'
+        subject.get('key').should == 'value'
+      end
+
+      it 'can create new key values' do
+        subject.set('key', 'value').should == 'value'
+        ResqueValue.first.value.should == 'value'
+      end
+
+      it 'can delete key values' do
+        subject.set('key', 'value').should == 'value'
+        subject.del('key')
+        subject.get('key').should be_nil
+      end
+
+      it 'can get multiple values by keys' do
+        subject.set('key-1', 'one')
+        subject.set('key-2', 'two')
+        subject.mapped_mget('key-1', 'key-2')['key-1'].should == 'one'
+        subject.mapped_mget('key-1', 'key-2')['key-2'].should == 'two'
+      end
+
+      it 'always returns all keys when pattern is *' do
+        subject.set('key-1', 'one')
+        subject.set('key-2', 'two')
+        subject.keys('*').should include('key-1', 'key-2')
+      end
+
+      it 'raises error when pattern is not *' do
+        lambda{subject.keys('something not *')}.should raise_error
+      end
+    end
+
+    describe 'managing workes in a set' do
+      it 'can add workers to the queue' do
+        worker = Resque::Worker.new(queues = ['queue1'])
+        subject.sadd(:workers, worker)
+        ResqueValue.first.value.should == worker.to_s
+      end
+
+      it 'returns all values in the workers set' do
+        worker = Resque::Worker.new(queues = ['queue1'])
+        subject.sadd(:workers, worker)
+        subject.smembers(:workers).first.should == worker.to_s
+      end
+
+      it 'removes a worker from the workers set by name' do
+        worker = Resque::Worker.new(queues = ['queue1'])
+        subject.sadd(:workers, worker)
+        subject.srem(:workers, worker)
+        subject.smembers(:workers).should be_empty
+      end
+
+      it 'should only add a value to a set once' do
+        subject.sadd(:test, 'one')
+        subject.sadd(:test, 'one')
+        subject.smembers(:test).size.should == 1
+      end
+
+      it 'indicates when worker is in the workers set' do
+        worker = Resque::Worker.new(queues = ['queue1'])
+
+        subject.sismember(:workers, worker).should == false
+        subject.sadd(:workers, worker)
+        subject.sismember(:workers, worker).should == true
+      end
+
+      it 'can delete a whole set by name'  do
+        subject.sadd(:test, 'one')
+        subject.sadd(:test, 'two')
+        subject.del(:test)
+        subject.smembers(:test).should be_empty
+      end
+    end
+
+    describe 'working with lists' do
+      it 'should return nil if no items on a queue' do
+        subject.lpop('some_queue').should be_nil
+      end
+
+      it 'ingores index and adds item to list' do
+        subject.lset('some_queue', 88, 'value')
+        subject.llen('some_queue').should == 1
+      end
+
+      it 'should add item to queue and then pop it back off' do
+        subject.rpush('some_queue', 'value')
+        subject.lpop('some_queue').should == 'value'
+        subject.lpop('some_queue').should be_nil
+      end
+
+      it 'should tell you how many items are in a list' do
+        subject.rpush('some_queue', 'one')
+        subject.rpush('some_queue', 'two')
+        subject.llen('some_queue').should == 2
+      end
+
+      it 'should be able to paginate through a list' do
+        subject.rpush('some_queue', 'one')
+        subject.rpush('some_queue', 'two')
+        subject.rpush('some_queue', 'three')
+        subject.lrange('some_queue', 0, 1).first.should == 'one'
+        subject.lrange('some_queue', 2, 3).first.should == 'three'
+      end
+
+      it 'should get all results if you pass -1 to lrange' do
+        subject.rpush('some_queue', 'one')
+        subject.rpush('some_queue', 'two')
+        subject.rpush('some_queue', 'three')
+        subject.lrange('some_queue', 0, -1).should include('one', 'two', 'three')
+      end
+
+      it 'should remove items from queue' do
+        subject.rpush('some_queue', 'one')
+        subject.rpush('some_queue', 'two')
+        subject.rpush('some_queue', 'two')
+        subject.lrem('some_queue', 0, 'two').should == 2
+        subject.lrange('some_queue', 0, -1).should include('one')
+      end
+
+      it "should trim according to the specifed start and end" do
+        1.upto(6){|i| subject.rpush('some_queue', i)}
+        subject.ltrim('some_queue', 1, 3)
+        subject.llen('some_queue').should == 3
+        subject.lrange('some_queue', 0, 2).should == ["2","3","4"]
+      end
+
+      it "should not affect other keys when trimming" do
+        1.upto(3){|i| subject.rpush('some_queue', i)}
+        subject.set('something_else', 'independent value')
+        subject.ltrim('some_queue', 0, 0)
+        subject.get('something_else').should == 'independent value'
+      end
+
+      it "should get a range of values" do
+        1.upto(6){|i| subject.rpush('some_queue', i)}
+        subject.lrange('some_queue', 0, 5).should == ['1','2','3','4','5','6']
+        subject.lrange('some_queue', 1, 3).should == ['2','3','4']
+      end
+    end
+
+    it 'should increment a value' do
+      subject.incrby('something', 2)
+      subject.get('something').should == '2'
+      subject.incrby('something', 1)
+      subject.get('something').should == '3'
+    end
+
+    it 'should decrement a value' do
+      subject.incrby('something', 2)
+      subject.get('something').should == '2'
+      subject.decrby('something', 1)
+      subject.get('something').should == '1'
+    end
+
+  end
+end