viximo-cache-money 0.3.0

data/spec/cash/local_buffer_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+module Cash
+  describe LocalBuffer do
+    it "should have method missing as a private method" do
+      LocalBuffer.private_instance_methods.should include("method_missing")
+    end
+  end
+end

data/spec/cash/local_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+module Cash
+  describe Local do
+    it "should have method missing as a private method" do
+      Local.private_instance_methods.should include("method_missing")
+    end
+  end
+end

data/spec/cash/lock_spec.rb

@@ -0,0 +1,110 @@
+require "spec_helper"
+
+module Cash
+  describe Lock do
+    let(:lock) { Cash::Lock.new($memcache) }
+    
+    describe '#synchronize' do
+      it "yields the block" do
+        block_was_called = false
+        lock.synchronize('lock_key') do
+          block_was_called = true
+        end
+        block_was_called.should == true
+      end
+
+      it "acquires the specified lock before the block is run" do
+        $memcache.get("lock/lock_key").should == nil
+        lock.synchronize('lock_key') do
+           $memcache.get("lock/lock_key").should_not == nil
+         end
+      end
+
+      it "releases the lock after the block is run" do
+        $memcache.get("lock/lock_key").should == nil
+        lock.synchronize('lock_key') {}
+        $memcache.get("lock/lock_key").should == nil
+      end
+
+      it "releases the lock even if the block raises" do
+        $memcache.get("lock/lock_key").should == nil
+        lock.synchronize('lock_key') { raise } rescue nil
+        $memcache.get("lock/lock_key").should == nil
+      end
+
+      it "does not block on recursive lock acquisition" do
+        lock.synchronize('lock_key') do
+          lambda { lock.synchronize('lock_key') {} }.should_not raise_error
+        end
+      end
+    end
+
+    describe '#acquire_lock' do
+      it "creates a lock at a given cache key" do
+        $memcache.get("lock/lock_key").should == nil
+        lock.acquire_lock("lock_key")
+        $memcache.get("lock/lock_key").should_not == nil
+      end
+
+      describe 'when given a timeout for the lock' do
+        it "correctly sets timeout on memcache entries" do
+          mock($memcache).add('lock/lock_key', "#{Socket.gethostname} #{Process.pid}", timeout = 10) { true }
+          # lock.acquire_lock('lock_key', timeout)
+          lambda { lock.acquire_lock('lock_key', timeout, 1) }.should raise_error
+        end
+      end
+
+      describe 'when to processes contend for a lock' do
+        it "prevents two processes from acquiring the same lock at the same time" do
+          lock.acquire_lock('lock_key')
+          as_another_process do
+            stub(lock).exponential_sleep
+            lambda { lock.acquire_lock('lock_key') }.should raise_error
+          end
+        end
+        
+        describe 'when given a number of times to retry' do
+          it "retries specified number of times" do
+            lock.acquire_lock('lock_key')
+            as_another_process do
+              mock($memcache).add("lock/lock_key", "#{Socket.gethostname} #{Process.pid}", timeout = 10) { false }.times(retries = 3)
+              stub(lock).exponential_sleep
+              lambda { lock.acquire_lock('lock_key', timeout, retries) }.should raise_error
+            end
+          end
+        end
+        
+        describe 'when given an initial wait' do
+          it 'sleeps exponentially starting with the initial wait' do
+            stub(lock).sleep(initial_wait = 0.123)
+            stub(lock).sleep(2 * initial_wait)
+            stub(lock).sleep(4 * initial_wait)
+            stub(lock).sleep(8 * initial_wait)
+            lock.acquire_lock('lock_key')
+            as_another_process do
+              lambda { lock.acquire_lock('lock_key', Lock::DEFAULT_EXPIRY, Lock::DEFAULT_RETRY, initial_wait) }.should raise_error
+            end            
+          end
+        end
+
+        def as_another_process
+          current_pid = Process.pid
+          stub(Process).pid { current_pid + 1 }
+          yield
+        end
+        
+      end
+
+    end
+
+    describe '#release_lock' do
+      it "deletes the lock for a given cache key" do
+        $memcache.get("lock/lock_key").should == nil
+        lock.acquire_lock("lock_key")
+        $memcache.get("lock/lock_key").should_not == nil
+        lock.release_lock("lock_key")
+        $memcache.get("lock/lock_key").should == nil
+      end
+    end
+  end
+end

data/spec/cash/marshal_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe Marshal do
+  describe '#load' do
+    before do
+      class Constant; end
+      @reference_to_constant = Constant
+      @object = @reference_to_constant.new
+      @marshaled_object = Marshal.dump(@object)
+    end
+
+    describe 'when the constant is not yet loaded' do
+      it 'loads the constant' do
+        Object.send(:remove_const, :Constant)
+        stub(Marshal).constantize(@reference_to_constant.name) { Object.send(:const_set, :Constant, @reference_to_constant) }
+        Marshal.load(@marshaled_object).class.should == @object.class
+      end
+
+      it 'loads the constant with the scope operator' do
+        module Foo; class Bar; end; end
+        
+        reference_to_module = Foo
+        reference_to_constant = Foo::Bar
+        object = reference_to_constant.new
+        marshaled_object = Marshal.dump(object)
+
+        Foo.send(:remove_const, :Bar)
+        Object.send(:remove_const, :Foo)
+        stub(Marshal).constantize(reference_to_module.name) { Object.send(:const_set, :Foo, reference_to_module) }
+        stub(Marshal).constantize(reference_to_constant.name) { Foo.send(:const_set, :Bar, reference_to_constant) }
+        
+        Marshal.load(marshaled_object).class.should == object.class
+      end
+    end
+
+    describe 'when the constant does not exist' do
+      it 'raises a LoadError' do
+        Object.send(:remove_const, :Constant)
+        stub(Marshal).constantize { raise NameError }
+        lambda { Marshal.load(@marshaled_object) }.should raise_error(NameError)
+      end
+    end
+
+    describe 'when there are recursive constants to load' do
+      it 'loads all constants recursively' do
+        class Constant1; end
+        class Constant2; end
+        reference_to_constant1 = Constant1
+        reference_to_constant2 = Constant2
+        object = [reference_to_constant1.new, reference_to_constant2.new]
+        marshaled_object = Marshal.dump(object)
+        Object.send(:remove_const, :Constant1)
+        Object.send(:remove_const, :Constant2)
+        stub(Marshal).constantize(reference_to_constant1.name) { Object.send(:const_set, :Constant1, reference_to_constant1) }
+        stub(Marshal).constantize(reference_to_constant2.name) { Object.send(:const_set, :Constant2, reference_to_constant2) }
+        Marshal.load(marshaled_object).collect(&:class).should == object.collect(&:class)
+      end
+    end
+  end
+end

data/spec/cash/order_spec.rb

@@ -0,0 +1,172 @@
+require "spec_helper"
+
+module Cash
+  describe 'Ordering' do
+    before :suite do
+      FairyTale = Class.new(Story)
+    end
+
+    describe '#create!' do
+      describe 'the records are written-through in sorted order', :shared => true do
+        describe 'when there are not already records matching the index' do
+          it 'initializes the index' do
+            fairy_tale = FairyTale.create!(:title => 'title')
+            FairyTale.get("title/#{fairy_tale.title}").should == [fairy_tale.id]
+          end
+        end
+
+        describe 'when there are already records matching the index' do
+          before do
+            @fairy_tale1 = FairyTale.create!(:title => 'title')
+            FairyTale.get("title/#{@fairy_tale1.title}").should == sorted_and_serialized_records(@fairy_tale1)
+          end
+
+          describe 'when the index is populated' do
+            it 'appends to the index' do
+              fairy_tale2 = FairyTale.create!(:title => @fairy_tale1.title)
+              FairyTale.get("title/#{@fairy_tale1.title}").should == sorted_and_serialized_records(@fairy_tale1, fairy_tale2)
+            end
+          end
+
+          describe 'when the index is not populated' do
+            before do
+              $memcache.flush_all
+            end
+
+            it 'initializes the index' do
+              fairy_tale2 = FairyTale.create!(:title => @fairy_tale1.title)
+              FairyTale.get("title/#{@fairy_tale1.title}").should == sorted_and_serialized_records(@fairy_tale1, fairy_tale2)
+            end
+          end
+        end
+      end
+
+      describe 'when the order is ascending' do
+        it_should_behave_like 'the records are written-through in sorted order'
+
+        before :all do
+          FairyTale.index :title, :order => :asc
+        end
+
+        def sorted_and_serialized_records(*records)
+          records.collect(&:id).sort
+        end
+      end
+
+      describe 'when the order is descending' do
+        it_should_behave_like 'the records are written-through in sorted order'
+
+        before :all do
+          FairyTale.index :title, :order => :desc
+        end
+
+        def sorted_and_serialized_records(*records)
+          records.collect(&:id).sort.reverse
+        end
+      end
+    end
+
+    describe "#find(..., :order => ...)" do
+      before :each do
+        @fairy_tales = [FairyTale.create!(:title => @title = 'title'), FairyTale.create!(:title => @title)]
+      end
+
+      describe 'when the order is ascending' do
+        before :all do
+          FairyTale.index :title, :order => :asc
+        end
+
+        describe "#find(..., :order => 'id ASC')" do
+          describe 'when the cache is populated' do
+            it 'does not use the database' do
+              mock(FairyTale.connection).execute.never
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id ASC').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`id`').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'stories.id').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`stories`.id').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`stories`.`id`').should == @fairy_tales
+            end
+
+            describe 'when the order is passed as a symbol' do
+              it 'works' do
+                FairyTale.find(:all, :conditions => { :title => @title }, :order => :id)
+              end
+            end
+          end
+
+          describe 'when the cache is not populated' do
+            it 'populates the cache' do
+              $memcache.flush_all
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id ASC').should == @fairy_tales
+              FairyTale.get("title/#{@title}").should == @fairy_tales.collect(&:id)
+            end
+          end
+        end
+
+        describe "#find(..., :order => 'id DESC')" do
+          describe 'when the cache is populated' do
+            it 'uses the database, not the cache' do
+              mock(FairyTale).get.never
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC').should == @fairy_tales.reverse
+            end
+          end
+
+          describe 'when the cache is not populated' do
+            it 'does not populate the cache' do
+              $memcache.flush_all
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC').should == @fairy_tales.reverse
+              FairyTale.get("title/#{@title}").should be_nil
+            end
+          end
+        end
+      end
+
+      describe 'when the order is descending' do
+        before :all do
+          FairyTale.index :title, :order => :desc
+        end
+
+        describe "#find(..., :order => 'id DESC')" do
+          describe 'when the cache is populated' do
+            it 'does not use the database' do
+              mock(FairyTale.connection).execute.never
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC').should == @fairy_tales.reverse
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC').should == @fairy_tales.reverse
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`id` DESC').should == @fairy_tales.reverse
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'stories.id DESC').should == @fairy_tales.reverse
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`stories`.id DESC').should == @fairy_tales.reverse
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => '`stories`.`id` DESC').should == @fairy_tales.reverse
+            end
+          end
+
+          describe 'when the cache is not populated' do
+            it 'populates the cache' do
+              $memcache.flush_all
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id DESC')
+              FairyTale.get("title/#{@title}").should == @fairy_tales.collect(&:id).reverse
+            end
+          end
+        end
+
+        describe "#find(..., :order => 'id ASC')" do
+          describe 'when the cache is populated' do
+            it 'uses the database, not the cache' do
+              mock(FairyTale).get.never
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id ASC').should == @fairy_tales
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id').should == @fairy_tales
+            end
+          end
+
+          describe 'when the cache is not populated' do
+            it 'does not populate the cache' do
+              $memcache.flush_all
+              FairyTale.find(:all, :conditions => { :title => @title }, :order => 'id ASC').should == @fairy_tales
+              FairyTale.get("title/#{@title}").should be_nil
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/spec/cash/transactional_spec.rb

@@ -0,0 +1,602 @@
+require "spec_helper"
+
+module Cash
+  describe Transactional do
+    let(:lock) { Cash::Lock.new($memcache) }
+    
+    before do
+      @cache = Transactional.new($memcache, lock)
+      @value = "stuff to be cached"
+      @key   = "key"
+    end
+
+    describe 'Basic Operations' do
+      it "gets through the real cache" do
+        $memcache.set(@key, @value)
+        @cache.get(@key).should == @value
+      end
+
+      it "sets through the real cache" do
+        mock($memcache).set(@key, @value, :option1, :option2)
+        @cache.set(@key, @value, :option1, :option2)
+      end
+
+      it "increments through the real cache" do
+        @cache.set(@key, 0, 0, true)
+        @cache.incr(@key, 3)
+
+        @cache.get(@key, true).to_i.should == 3
+        $memcache.get(@key, true).to_i.should == 3
+      end
+
+      it "decrements through the real cache" do
+        @cache.set(@key, 0, 0, true)
+        @cache.incr(@key, 3)
+        @cache.decr(@key, 2)
+
+        @cache.get(@key, true).to_i.should == 1
+        $memcache.get(@key, true).to_i.should == 1
+      end
+
+      it "adds through the real cache" do
+        @cache.add(@key, @value)
+        $memcache.get(@key).should == @value
+        @cache.get(@key).should == @value
+
+        @cache.add(@key, "another value")
+        $memcache.get(@key).should == @value
+        @cache.get(@key).should == @value
+      end
+
+      it "deletes through the real cache" do
+        $memcache.add(@key, @value)
+        $memcache.get(@key).should == @value
+
+        @cache.delete(@key)
+        $memcache.get(@key).should be_nil
+      end
+
+      it "returns true for respond_to? with what it responds to" do
+        @cache.respond_to?(:get).should be_true
+        @cache.respond_to?(:set).should be_true
+        @cache.respond_to?(:get_multi).should be_true
+        @cache.respond_to?(:incr).should be_true
+        @cache.respond_to?(:decr).should be_true
+        @cache.respond_to?(:add).should be_true
+      end
+
+      it "delegates unsupported messages back to the real cache" do
+        mock($memcache).foo(:bar)
+        @cache.foo(:bar)
+      end
+
+      describe '#get_multi' do
+        describe 'when everything is a hit' do
+          it 'returns a hash' do
+            @cache.set('key1', @value)
+            @cache.set('key2', @value)
+            @cache.get_multi('key1', 'key2').should == { 'key1' => @value, 'key2' => @value }
+          end
+        end
+
+        describe 'when there are misses' do
+          it 'only returns results for hits' do
+            @cache.set('key1', @value)
+            @cache.get_multi('key1', 'key2').should == { 'key1' => @value }
+          end
+        end
+      end
+    end
+
+    describe 'In a Transaction' do
+      it "commits to the real cache" do
+        $memcache.get(@key).should == nil
+        @cache.transaction do
+          @cache.set(@key, @value)
+        end
+        $memcache.get(@key).should == @value
+      end
+
+      describe 'when there is a return/next/break in the transaction' do
+        it 'commits to the real cache' do
+          $memcache.get(@key).should == nil
+          @cache.transaction do
+            @cache.set(@key, @value)
+            next
+          end
+          $memcache.get(@key).should == @value
+        end
+      end
+
+      it "reads through the real cache if key has not been written to" do
+        $memcache.set(@key, @value)
+        @cache.transaction do
+          @cache.get(@key).should == @value
+        end
+        @cache.get(@key).should == @value
+      end
+
+      it "delegates unsupported messages back to the real cache" do
+        @cache.transaction do
+          mock($memcache).foo(:bar)
+          @cache.foo(:bar)
+        end
+      end
+
+      it "returns the result of the block passed to the transaction" do
+        @cache.transaction do
+          :result
+        end.should == :result
+      end
+
+      describe 'Increment and Decrement' do
+        describe '#incr' do
+          it "works" do
+            @cache.set(@key, 0, 0, true)
+            @cache.incr(@key)
+            @cache.transaction do
+              @cache.incr(@key).should == 2
+            end
+          end
+
+          it "is buffered" do
+            @cache.transaction do
+              @cache.set(@key, 0, 0, true)
+              @cache.incr(@key, 2).should == 2
+              @cache.get(@key).should == 2
+              $memcache.get(@key).should == nil
+            end
+            @cache.get(@key, true).to_i.should == 2
+            $memcache.get(@key, true).to_i.should == 2
+          end
+
+          it "returns nil if there is no key already at that value" do
+            @cache.transaction do
+              @cache.incr(@key).should == nil
+            end
+          end
+
+        end
+
+        describe '#decr' do
+          it "works" do
+            @cache.set(@key, 0, 0, true)
+            @cache.incr(@key)
+            @cache.transaction do
+              @cache.decr(@key).should == 0
+            end
+          end
+
+          it "is buffered" do
+            @cache.transaction do
+              @cache.set(@key, 0, 0, true)
+              @cache.incr(@key, 3)
+              @cache.decr(@key, 2).should == 1
+              @cache.get(@key, true).to_i.should == 1
+              $memcache.get(@key).should == nil
+            end
+            @cache.get(@key, true).to_i.should == 1
+            $memcache.get(@key, true).to_i.should == 1
+          end
+
+          it "returns nil if there is no key already at that value" do
+            @cache.transaction do
+              @cache.decr(@key).should == nil
+            end
+          end
+
+          it "bottoms out at zero" do
+            @cache.transaction do
+              @cache.set(@key, 0, 0, true)
+              @cache.incr(@key, 1)
+              @cache.get(@key, true).should == 1
+              @cache.decr(@key)
+              @cache.get(@key, true).should == 0
+              @cache.decr(@key)
+              @cache.get(@key, true).should == 0
+            end
+          end
+        end
+      end
+
+      describe '#get_multi' do
+        describe 'when a hit value is the empty array' do
+          it 'returns a hash' do
+            @cache.transaction do
+              @cache.set('key1', @value)
+              @cache.set('key2', [])
+              @cache.get_multi('key1', 'key2').should == { 'key1' => @value, 'key2' => [] }
+            end
+          end
+        end
+
+        describe 'when everything is a hit' do
+          it 'returns a hash' do
+            @cache.transaction do
+              @cache.set('key1', @value)
+              @cache.set('key2', @value)
+              @cache.get_multi('key1', 'key2').should == { 'key1' => @value, 'key2' => @value }
+            end
+          end
+        end
+
+        describe 'when there are misses' do
+          it 'only returns results for hits' do
+            @cache.transaction do
+              @cache.set('key1', @value)
+              @cache.get_multi('key1', 'key2').should == { 'key1' => @value }
+            end
+          end
+        end
+      end
+
+      describe 'Lock Acquisition' do
+        it "locks @keys to be written before writing to memcache and release them after" do
+          mock(lock).acquire_lock(@key)
+          mock($memcache).set(@key, @value)
+          mock(lock).release_lock(@key)
+
+          @cache.transaction do
+            @cache.set(@key, @value)
+          end
+        end
+
+        it "does not acquire locks on reads" do
+          mock(lock).acquire_lock.never
+          mock(lock).release_lock.never
+
+          @cache.transaction do
+            @cache.get(@key)
+          end
+        end
+
+        it "locks @keys in lexically sorted order" do
+          keys = ['c', 'a', 'b']
+          keys.sort.inject(mock(lock)) do |mock, key|
+            mock.acquire_lock(key).then
+          end
+          keys.each { |key| mock($memcache).set(key, @value) }
+          keys.each { |key| mock(lock).release_lock(key) }
+          @cache.transaction do
+            @cache.set(keys[0], @value)
+            @cache.set(keys[1], @value)
+            @cache.set(keys[2], @value)
+          end
+        end
+
+        it "releases locks even if memcache blows up" do
+          mock(lock).acquire_lock.with(@key)
+          mock(lock).release_lock.with(@key)
+          stub($memcache).set(anything, anything) { raise }
+          @cache.transaction do
+            @cache.set(@key, @value)
+          end rescue nil
+        end
+
+      end
+
+      describe 'Buffering' do
+        it "reading from the cache show uncommitted writes" do
+          @cache.get(@key).should == nil
+          @cache.transaction do
+            @cache.set(@key, @value)
+            @cache.get(@key).should == @value
+          end
+        end
+
+        it "get is buffered using shallow clones for ActiveRecord objects" do
+          @value = Story.create!
+          @cache.transaction do
+            @cache.set(@key, @value)
+            @cache.get(@key).should == @value
+            @cache.get(@key).should_not equal(@value)
+            $memcache.get(@key).should == nil
+          end
+        end
+
+        it "get_multi is buffered" do
+          @cache.transaction do
+            @cache.set('key1', @value)
+            @cache.set('key2', @value)
+            @cache.get_multi('key1', 'key2').should == { 'key1' => @value, 'key2' => @value }
+            $memcache.get_multi('key1', 'key2').should == {}
+          end
+        end
+
+        it "get_multi is buffered using shallow clones for ActiveRecord objects" do
+          @value = Story.create!
+          @cache.transaction do
+            @cache.set('key1', @value)
+            @cache.set('key2', @value)
+            @cache.get_multi('key1', 'key2').should == { 'key1' => @value, 'key2' => @value }
+            @cache.get_multi('key1', 'key2')['key1'].should_not equal(@value)
+            @cache.get_multi('key1', 'key2')['key2'].should_not equal(@value)
+            $memcache.get_multi('key1', 'key2').should == {}
+          end
+        end
+
+        it "get is memoized" do
+          @cache.set(@key, @value)
+          @cache.transaction do
+            @cache.get(@key).should == @value
+            $memcache.set(@key, "new value")
+            @cache.get(@key).should == @value
+          end
+        end
+
+        it "add is buffered" do
+          @cache.transaction do
+            @cache.add(@key, @value)
+            $memcache.get(@key).should == nil
+            @cache.get(@key).should == @value
+          end
+          @cache.get(@key).should == @value
+          $memcache.get(@key).should == @value
+        end
+
+        describe '#delete' do
+          it "within a transaction, delete is isolated" do
+            @cache.add(@key, @value)
+            @cache.transaction do
+              @cache.delete(@key)
+              $memcache.add(@key, "another value")
+            end
+            @cache.get(@key).should == nil
+            $memcache.get(@key).should == nil
+          end
+
+          it "within a transaction, delete is buffered" do
+            @cache.set(@key, @value)
+            @cache.transaction do
+              @cache.delete(@key)
+              $memcache.get(@key).should == @value
+              @cache.get(@key).should == nil
+            end
+            @cache.get(@key).should == nil
+            $memcache.get(@key).should == nil
+          end
+        end
+      end
+
+      describe '#incr' do
+        it "increment be atomic" do
+          @cache.set(@key, 0, 0, true)
+          @cache.transaction do
+            @cache.incr(@key)
+            $memcache.incr(@key)
+          end
+          @cache.get(@key, true).to_i.should == 2
+          $memcache.get(@key, true).to_i.should == 2
+        end
+
+        it "interleaved, etc. increments and sets be ordered" do
+          @cache.set(@key, 0, 0, true)
+          @cache.transaction do
+            @cache.incr(@key)
+            @cache.incr(@key)
+            @cache.set(@key, 0, 0, true)
+            @cache.incr(@key)
+            @cache.incr(@key)
+          end
+          @cache.get(@key, true).to_i.should == 2
+          $memcache.get(@key, true).to_i.should == 2
+        end
+      end
+
+      describe '#decr' do
+        it "decrement be atomic" do
+          @cache.set(@key, 0, 0, true)
+          @cache.incr(@key, 3)
+          @cache.transaction do
+            @cache.decr(@key)
+            $memcache.decr(@key)
+          end
+          @cache.get(@key, true).to_i.should == 1
+          $memcache.get(@key, true).to_i.should == 1
+        end
+      end
+
+      it "retains the value in the transactional cache after committing the transaction" do
+        @cache.get(@key).should == nil
+        @cache.transaction do
+          @cache.set(@key, @value)
+        end
+        @cache.get(@key).should == @value
+      end
+
+      describe 'when reading from the memcache' do
+        it "does NOT show uncommitted writes" do
+          @cache.transaction do
+            $memcache.get(@key).should == nil
+            @cache.set(@key, @value)
+            $memcache.get(@key).should == nil
+          end
+        end
+      end
+    end
+
+    describe 'Exception Handling' do
+
+      it "re-raises exceptions thrown by memcache" do
+        stub($memcache).set(anything, anything) { raise }
+        lambda do
+          @cache.transaction do
+            @cache.set(@key, @value)
+          end
+        end.should raise_error
+      end
+
+      it "rolls back transaction cleanly if an exception is raised" do
+        $memcache.get(@key).should == nil
+        @cache.get(@key).should == nil
+        @cache.transaction do
+          @cache.set(@key, @value)
+          raise
+        end rescue nil
+        @cache.get(@key).should == nil
+        $memcache.get(@key).should == nil
+      end
+
+      it "does not acquire locks if transaction is rolled back" do
+        mock(lock).acquire_lock.never
+        mock(lock).release_lock.never
+
+        @cache.transaction do
+          @cache.set(@key, value)
+          raise
+        end rescue nil
+      end
+    end
+
+    describe 'Nested Transactions' do
+      it "delegate unsupported messages back to the real cache" do
+        @cache.transaction do
+          @cache.transaction do
+            @cache.transaction do
+              mock($memcache).foo(:bar)
+              @cache.foo(:bar)
+            end
+          end
+        end
+      end
+
+      it "makes newly set keys only be visible within the transaction in which they were set" do
+        @cache.transaction do
+          @cache.set('key1', @value)
+          @cache.transaction do
+            @cache.get('key1').should == @value
+            @cache.set('key2', @value)
+            @cache.transaction do
+              @cache.get('key1').should == @value
+              @cache.get('key2').should == @value
+              @cache.set('key3', @value)
+            end
+          end
+          @cache.get('key1').should == @value
+          @cache.get('key2').should == @value
+          @cache.get('key3').should == @value
+        end
+        @cache.get('key1').should == @value
+        @cache.get('key2').should == @value
+        @cache.get('key3').should == @value
+      end
+
+      it "not write any values to memcache until the outermost transaction commits" do
+        @cache.transaction do
+          @cache.set('key1', @value)
+          @cache.transaction do
+            @cache.set('key2', @value)
+            $memcache.get('key1').should == nil
+            $memcache.get('key2').should == nil
+          end
+          $memcache.get('key1').should == nil
+          $memcache.get('key2').should == nil
+        end
+        $memcache.get('key1').should == @value
+        $memcache.get('key2').should == @value
+      end
+
+      it "acquire locks in lexical order for all keys" do
+        keys = ['c', 'a', 'b']
+        keys.sort.inject(mock(lock)) do |mock, key|
+          mock.acquire_lock(key).then
+        end
+        keys.each { |key| mock($memcache).set(key, @value) }
+        keys.each { |key| mock(lock).release_lock(key) }
+        @cache.transaction do
+          @cache.set(keys[0], @value)
+          @cache.transaction do
+            @cache.set(keys[1], @value)
+            @cache.transaction do
+              @cache.set(keys[2], @value)
+            end
+          end
+        end
+      end
+
+      it "reads through the real memcache if key has not been written to in a transaction" do
+        $memcache.set(@key, @value)
+        @cache.transaction do
+          @cache.transaction do
+            @cache.transaction do
+              @cache.get(@key).should == @value
+            end
+          end
+        end
+        @cache.get(@key).should == @value
+      end
+
+      describe 'Error Handling' do
+        it "releases locks even if memcache blows up" do
+          mock(lock).acquire_lock(@key)
+          mock(lock).release_lock(@key)
+          stub($memcache).set(anything, anything) { raise }
+          @cache.transaction do
+            @cache.transaction do
+              @cache.transaction do
+                @cache.set(@key, @value)
+              end
+            end
+          end rescue nil
+        end
+
+        it "re-raise exceptions thrown by memcache" do
+          stub($memcache).set(anything, anything) { raise }
+          lambda do
+            @cache.transaction do
+              @cache.transaction do
+                @cache.transaction do
+                  @cache.set(@key, @value)
+                end
+              end
+            end
+          end.should raise_error
+        end
+
+        it "rollback transaction cleanly if an exception is raised" do
+          $memcache.get(@key).should == nil
+          @cache.get(@key).should == nil
+          @cache.transaction do
+            @cache.transaction do
+              @cache.set(@key, @value)
+              raise
+            end
+          end rescue nil
+          @cache.get(@key).should == nil
+          $memcache.get(@key).should == nil
+        end
+
+        it "not acquire locks if transaction is rolled back" do
+          mock(lock).acquire_lock.never
+          mock(lock).release_lock.never
+
+          @cache.transaction do
+            @cache.transaction do
+              @cache.set(@key, @value)
+              raise
+            end
+          end rescue nil
+        end
+
+        it "support rollbacks" do
+          @cache.transaction do
+            @cache.set('key1', @value)
+            @cache.transaction do
+              @cache.get('key1').should == @value
+              @cache.set('key2', @value)
+              raise
+            end rescue nil
+            @cache.get('key1').should == @value
+            @cache.get('key2').should == nil
+          end
+          $memcache.get('key1').should == @value
+          $memcache.get('key2').should == nil
+        end
+      end
+    end
+
+    it "should have method_missing as a private method" do
+      Transactional.private_instance_methods.should include("method_missing")
+    end
+  end
+end