dm-core 0.9.11 → 0.10.0

data/spec/unit/scope_spec.rb

@@ -1,142 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe DataMapper::Scope do
-  after do
-    Article.publicize_methods do
-      Article.scope_stack.clear  # reset the stack before each spec
-    end
-  end
-
-  describe '.with_scope' do
-    it 'should be protected' do
-      klass = class << Article; self; end
-      klass.should be_protected_method_defined(:with_scope)
-    end
-
-    it 'should set the current scope for the block when given a Hash' do
-      Article.publicize_methods do
-        Article.with_scope :blog_id => 1 do
-          Article.query.should == DataMapper::Query.new(repository(:mock), Article, :blog_id => 1)
-        end
-      end
-    end
-
-    it 'should set the current scope for the block when given a DataMapper::Query' do
-      Article.publicize_methods do
-        Article.with_scope query = DataMapper::Query.new(repository(:mock), Article) do
-          Article.query.should == query
-        end
-      end
-    end
-
-    it 'should set the current scope for an inner block, merged with the outer scope' do
-      Article.publicize_methods do
-        Article.with_scope :blog_id => 1 do
-          Article.with_scope :author => 'dkubb' do
-            Article.query.should == DataMapper::Query.new(repository(:mock), Article, :blog_id => 1, :author => 'dkubb')
-          end
-        end
-      end
-    end
-
-    it 'should reset the stack on error' do
-      Article.publicize_methods do
-        Article.query.should be_nil
-        lambda {
-          Article.with_scope(:blog_id => 1) { raise 'There was a problem!' }
-        }.should raise_error(RuntimeError)
-        Article.query.should be_nil
-      end
-    end
-  end
-
-  describe '.with_exclusive_scope' do
-    it 'should be protected' do
-      klass = class << Article; self; end
-      klass.should be_protected_method_defined(:with_exclusive_scope)
-    end
-
-    it 'should set the current scope for an inner block, ignoring the outer scope' do
-      Article.publicize_methods do
-        Article.with_scope :blog_id => 1 do
-          Article.with_exclusive_scope :author => 'dkubb' do
-            Article.query.should == DataMapper::Query.new(repository(:mock), Article, :author => 'dkubb')
-          end
-        end
-      end
-    end
-
-    it 'should reset the stack on error' do
-      Article.publicize_methods do
-        Article.query.should be_nil
-        lambda {
-          Article.with_exclusive_scope(:blog_id => 1) { raise 'There was a problem!' }
-        }.should raise_error(RuntimeError)
-        Article.query.should be_nil
-      end
-    end
-
-    it "should ignore the default_scope when using an exclusive scope" do
-      Article.default_scope.update(:blog_id => 1)
-      Article.publicize_methods do
-        Article.with_exclusive_scope(:author => 'dkubb') do
-          Article.query.should == DataMapper::Query.new(repository(:mock), Article, :author => 'dkubb')
-        end
-      end
-      Article.default_scope.delete(:blog_id)
-    end
-
-  end
-
-  describe '.scope_stack' do
-    it 'should be private' do
-      klass = class << Article; self; end
-      klass.should be_private_method_defined(:scope_stack)
-    end
-
-    it 'should provide an Array' do
-      Article.publicize_methods do
-        Article.scope_stack.should be_kind_of(Array)
-      end
-    end
-
-    it 'should be the same in a thread' do
-      Article.publicize_methods do
-        Article.scope_stack.object_id.should == Article.scope_stack.object_id
-      end
-    end
-
-    it 'should be different in each thread' do
-      Article.publicize_methods do
-        a = Thread.new { Article.scope_stack }
-        b = Thread.new { Article.scope_stack }
-
-        a.value.object_id.should_not == b.value.object_id
-      end
-    end
-  end
-
-  describe '.query' do
-    it 'should be public' do
-      klass = class << Article; self; end
-      klass.should be_public_method_defined(:query)
-    end
-
-    it 'should return nil if the scope stack is empty' do
-      Article.publicize_methods do
-        Article.scope_stack.should be_empty
-        Article.query.should be_nil
-      end
-    end
-
-    it 'should return the last element of the scope stack' do
-      Article.publicize_methods do
-        query = DataMapper::Query.new(repository(:mock), Article)
-        Article.scope_stack << query
-        Article.query.object_id.should == query.object_id
-      end
-    end
-  end
-
-  # TODO: specify the behavior of finders (all, first, get, []) when scope is in effect
-end

data/spec/unit/transaction_spec.rb

@@ -1,493 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe DataMapper::Transaction do
-
-  before :all do
-    class ::Smurf
-      include DataMapper::Resource
-      property :id, Integer, :key => true
-    end
-  end
-
-  before :each do
-    @adapter = mock("adapter", :name => 'mock_adapter')
-    @repository = mock("repository")
-    @repository_adapter = mock("repository adapter", :name => 'mock_repository_adapter')
-    @resource = Smurf.new
-    @transaction_primitive = mock("transaction primitive")
-    @repository_transaction_primitive = mock("repository transaction primitive")
-    @array = [@adapter, @repository]
-
-    @adapter.should_receive(:is_a?).any_number_of_times.with(Array).and_return(false)
-    @adapter.should_receive(:is_a?).any_number_of_times.with(DataMapper::Adapters::AbstractAdapter).and_return(true)
-    @adapter.should_receive(:transaction_primitive).any_number_of_times.and_return(@transaction_primitive)
-    @repository.should_receive(:is_a?).any_number_of_times.with(Array).and_return(false)
-    @repository.should_receive(:is_a?).any_number_of_times.with(DataMapper::Adapters::AbstractAdapter).and_return(false)
-    @repository.should_receive(:is_a?).any_number_of_times.with(DataMapper::Repository).and_return(true)
-    @repository.should_receive(:adapter).any_number_of_times.and_return(@repository_adapter)
-    @repository_adapter.should_receive(:is_a?).any_number_of_times.with(Array).and_return(false)
-    @repository_adapter.should_receive(:is_a?).any_number_of_times.with(DataMapper::Adapters::AbstractAdapter).and_return(true)
-    @repository_adapter.should_receive(:transaction_primitive).any_number_of_times.and_return(@repository_transaction_primitive)
-    @transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:close).and_return(true)
-    @transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:begin).and_return(true)
-    @transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:prepare).and_return(true)
-    @transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:rollback).and_return(true)
-    @transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:rollback_prepared).and_return(true)
-    @transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:commit).and_return(true)
-    @repository_transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:close).and_return(true)
-    @repository_transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:begin).and_return(true)
-    @repository_transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:prepare).and_return(true)
-    @repository_transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:rollback).and_return(true)
-    @repository_transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:rollback_prepared).and_return(true)
-    @repository_transaction_primitive.should_receive(:respond_to?).any_number_of_times.with(:commit).and_return(true)
-  end
-
-  it "should be able to initialize with an Array" do
-    DataMapper::Transaction.new(@array)
-  end
-  it "should be able to initialize with DataMapper::Adapters::AbstractAdapters" do
-    DataMapper::Transaction.new(@adapter)
-  end
-  it "should be able to initialize with DataMapper::Repositories" do
-    DataMapper::Transaction.new(@repository)
-  end
-  it "should be able to initialize with DataMapper::Resource subclasses" do
-    DataMapper::Transaction.new(Smurf)
-  end
-  it "should be able to initialize with DataMapper::Resources" do
-    DataMapper::Transaction.new(Smurf.new)
-  end
-  it "should initialize with no transaction_primitives" do
-    DataMapper::Transaction.new.transaction_primitives.empty?.should == true
-  end
-  it "should initialize with state :none" do
-    DataMapper::Transaction.new.state.should == :none
-  end
-  it "should initialize the adapters given on creation" do
-    DataMapper::Transaction.new(Smurf).adapters.should == {Smurf.repository.adapter => :none}
-  end
-  it "should be able receive multiple adapters on creation" do
-    DataMapper::Transaction.new(Smurf, @resource, @adapter, @repository)
-  end
-  it "should be able to initialize with a block" do
-    p = Proc.new do end
-    @transaction_primitive.stub!(:begin)
-    @transaction_primitive.stub!(:prepare)
-    @transaction_primitive.stub!(:commit)
-    @adapter.stub!(:push_transaction)
-    @adapter.stub!(:pop_transaction)
-    @transaction_primitive.stub!(:close)
-    DataMapper::Transaction.new(@adapter, &p)
-  end
-  it "should accept new adapters after creation" do
-    t = DataMapper::Transaction.new(@adapter, @repository)
-    t.adapters.should == {@adapter => :none, @repository_adapter => :none}
-    t.link(@resource)
-    t.adapters.should == {@adapter => :none, @repository_adapter => :none, Smurf.repository.adapter => :none}
-  end
-  it "should not accept new adapters after state is changed" do
-    t = DataMapper::Transaction.new(@adapter, @repository)
-    @transaction_primitive.stub!(:begin)
-    @repository_transaction_primitive.stub!(:begin)
-    t.begin
-    lambda do t.link(@resource) end.should raise_error(Exception, /Illegal state/)
-  end
-  describe "#begin" do
-    before :each do
-      @transaction = DataMapper::Transaction.new(@adapter, @repository)
-    end
-    it "should raise error if state is changed" do
-      @transaction_primitive.stub!(:begin)
-      @repository_transaction_primitive.stub!(:begin)
-      @transaction.begin
-      lambda do @transaction.begin end.should raise_error(Exception, /Illegal state/)
-    end
-    it "should try to connect each adapter (or log fatal error), then begin each adapter (or rollback and close)" do
-      @transaction.should_receive(:each_adapter).with(:connect_adapter, [:log_fatal_transaction_breakage])
-      @transaction.should_receive(:each_adapter).with(:begin_adapter, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
-      @transaction.begin
-    end
-    it "should leave with state :begin" do
-      @transaction_primitive.stub!(:begin)
-      @repository_transaction_primitive.stub!(:begin)
-      @transaction.begin
-      @transaction.state.should == :begin
-    end
-  end
-  describe "#rollback" do
-    before :each do
-      @transaction = DataMapper::Transaction.new(@adapter, @repository)
-    end
-    it "should raise error if state is :none" do
-      lambda do @transaction.rollback end.should raise_error(Exception, /Illegal state/)
-    end
-    it "should raise error if state is :commit" do
-      @transaction_primitive.stub!(:begin)
-      @repository_transaction_primitive.stub!(:begin)
-      @transaction_primitive.stub!(:prepare)
-      @repository_transaction_primitive.stub!(:prepare)
-      @transaction_primitive.stub!(:commit)
-      @repository_transaction_primitive.stub!(:commit)
-      @transaction_primitive.stub!(:close)
-      @repository_transaction_primitive.stub!(:close)
-      @transaction.begin
-      @transaction.commit
-      lambda do @transaction.rollback end.should raise_error(Exception, /Illegal state/)
-    end
-    it "should try to rollback each adapter (or rollback and close), then then close (or log fatal error)" do
-      @transaction.should_receive(:each_adapter).with(:connect_adapter, [:log_fatal_transaction_breakage])
-      @transaction.should_receive(:each_adapter).with(:begin_adapter, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
-      @transaction.should_receive(:each_adapter).with(:rollback_adapter_if_begin, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
-      @transaction.should_receive(:each_adapter).with(:close_adapter_if_open, [:log_fatal_transaction_breakage])
-      @transaction.should_receive(:each_adapter).with(:rollback_prepared_adapter_if_prepare, [:rollback_prepared_and_close_adapter_if_begin, :close_adapter_if_none])
-      @transaction.begin
-      @transaction.rollback
-    end
-    it "should leave with state :rollback" do
-      @transaction_primitive.stub!(:begin)
-      @repository_transaction_primitive.stub!(:begin)
-      @transaction_primitive.stub!(:rollback)
-      @repository_transaction_primitive.stub!(:rollback)
-      @transaction_primitive.stub!(:close)
-      @repository_transaction_primitive.stub!(:close)
-      @transaction.begin
-      @transaction.rollback
-      @transaction.state.should == :rollback
-    end
-  end
-  describe "#commit" do
-    describe "without a block" do
-      before :each do
-        @transaction = DataMapper::Transaction.new(@adapter, @repository)
-      end
-      it "should raise error if state is :none" do
-        lambda do @transaction.commit end.should raise_error(Exception, /Illegal state/)
-      end
-      it "should raise error if state is :commit" do
-        @transaction_primitive.stub!(:begin)
-        @repository_transaction_primitive.stub!(:begin)
-        @transaction_primitive.stub!(:prepare)
-        @repository_transaction_primitive.stub!(:prepare)
-        @transaction_primitive.stub!(:commit)
-        @repository_transaction_primitive.stub!(:commit)
-        @transaction_primitive.stub!(:close)
-        @repository_transaction_primitive.stub!(:close)
-        @transaction.begin
-        @transaction.commit
-        lambda do @transaction.commit end.should raise_error(Exception, /Illegal state/)
-      end
-      it "should raise error if state is :rollback" do
-        @transaction_primitive.stub!(:begin)
-        @repository_transaction_primitive.stub!(:begin)
-        @transaction_primitive.stub!(:rollback)
-        @repository_transaction_primitive.stub!(:rollback)
-        @transaction_primitive.stub!(:close)
-        @repository_transaction_primitive.stub!(:close)
-        @transaction.begin
-        @transaction.rollback
-        lambda do @transaction.commit end.should raise_error(Exception, /Illegal state/)
-      end
-      it "should try to prepare each adapter (or rollback and close), then commit each adapter (or log fatal error), then close (or log fatal error)" do
-        @transaction.should_receive(:each_adapter).with(:connect_adapter, [:log_fatal_transaction_breakage])
-        @transaction.should_receive(:each_adapter).with(:begin_adapter, [:rollback_and_close_adapter_if_begin, :close_adapter_if_none])
-        @transaction.should_receive(:each_adapter).with(:prepare_adapter, [:rollback_and_close_adapter_if_begin, :rollback_prepared_and_close_adapter_if_prepare])
-        @transaction.should_receive(:each_adapter).with(:commit_adapter, [:log_fatal_transaction_breakage])
-        @transaction.should_receive(:each_adapter).with(:close_adapter, [:log_fatal_transaction_breakage])
-        @transaction.begin
-        @transaction.commit
-      end
-      it "should leave with state :commit" do
-        @transaction_primitive.stub!(:begin)
-        @repository_transaction_primitive.stub!(:begin)
-        @transaction_primitive.stub!(:prepare)
-        @repository_transaction_primitive.stub!(:prepare)
-        @transaction_primitive.stub!(:commit)
-        @repository_transaction_primitive.stub!(:commit)
-        @transaction_primitive.stub!(:close)
-        @repository_transaction_primitive.stub!(:close)
-        @transaction.begin
-        @transaction.commit
-        @transaction.state.should == :commit
-      end
-    end
-    describe "with a block" do
-      before :each do
-        @transaction = DataMapper::Transaction.new(@adapter, @repository)
-      end
-      it "should raise if state is not :none" do
-        @transaction_primitive.stub!(:begin)
-        @repository_transaction_primitive.stub!(:begin)
-        @transaction.begin
-        lambda do @transaction.commit do end end.should raise_error(Exception, /Illegal state/)
-      end
-      it "should begin, yield and commit if the block raises no exception" do
-        @repository_transaction_primitive.should_receive(:begin)
-        @repository_transaction_primitive.should_receive(:prepare)
-        @repository_transaction_primitive.should_receive(:commit)
-        @repository_transaction_primitive.should_receive(:close)
-        @transaction_primitive.should_receive(:begin)
-        @transaction_primitive.should_receive(:prepare)
-        @transaction_primitive.should_receive(:commit)
-        @transaction_primitive.should_receive(:close)
-        p = Proc.new do end
-        @transaction.should_receive(:within).with(&p)
-        @transaction.commit(&p)
-      end
-      it "should rollback if the block raises an exception" do
-        @repository_transaction_primitive.should_receive(:begin)
-        @repository_transaction_primitive.should_receive(:rollback)
-        @repository_transaction_primitive.should_receive(:close)
-        @transaction_primitive.should_receive(:begin)
-        @transaction_primitive.should_receive(:rollback)
-        @transaction_primitive.should_receive(:close)
-        p = Proc.new do end
-        @transaction.should_receive(:within).with(&p).and_raise(Exception.new('test exception, never mind me'))
-        lambda { @transaction.commit(&p) }.should raise_error(Exception, /test exception, never mind me/)
-      end
-    end
-  end
-  describe "#within" do
-    before :each do
-      @transaction = DataMapper::Transaction.new(@adapter, @repository)
-    end
-    it "should raise if no block is provided" do
-      lambda do @transaction.within end.should raise_error(Exception, /No block/)
-    end
-    it "should raise if state is not :begin" do
-      lambda do @transaction.within do end end.should raise_error(Exception, /Illegal state/)
-    end
-    it "should push itself on the per thread transaction context of each adapter and then pop itself out again" do
-      @repository_transaction_primitive.should_receive(:begin)
-      @transaction_primitive.should_receive(:begin)
-      @repository_adapter.should_receive(:push_transaction).with(@transaction)
-      @adapter.should_receive(:push_transaction).with(@transaction)
-      @repository_adapter.should_receive(:pop_transaction)
-      @adapter.should_receive(:pop_transaction)
-      @transaction.begin
-      @transaction.within do end
-    end
-    it "should push itself on the per thread transaction context of each adapter and then pop itself out again even if an exception was raised" do
-      @repository_transaction_primitive.should_receive(:begin)
-      @transaction_primitive.should_receive(:begin)
-      @repository_adapter.should_receive(:push_transaction).with(@transaction)
-      @adapter.should_receive(:push_transaction).with(@transaction)
-      @repository_adapter.should_receive(:pop_transaction)
-      @adapter.should_receive(:pop_transaction)
-      @transaction.begin
-      lambda do @transaction.within do raise "test exception, never mind me" end end.should raise_error(Exception, /test exception, never mind me/)
-    end
-  end
-  describe "#method_missing" do
-    before :each do
-      @transaction = DataMapper::Transaction.new(@adapter, @repository)
-      @adapter.should_receive(:is_a?).any_number_of_times.with(any_args).and_return(false)
-      @adapter.should_receive(:is_a?).any_number_of_times.with(no_args).and_return(false)
-      @adapter.should_receive(:is_a?).any_number_of_times.with(Regexp).and_return(false)
-    end
-    it "should delegate calls to [a method we have]_if_[state](adapter) to [a method we have](adapter) if state of adapter is [state]" do
-      @transaction.should_receive(:state_for).with(@adapter).and_return(:begin)
-      @transaction.should_receive(:connect_adapter).with(@adapter)
-      @transaction.connect_adapter_if_begin(@adapter)
-    end
-    it "should not delegate calls to [a method we have]_if_[state](adapter) to [a method we have](adapter) if state of adapter is not [state]" do
-      @transaction.should_receive(:state_for).with(@adapter).and_return(:commit)
-      @transaction.should_not_receive(:connect_adapter).with(@adapter)
-      @transaction.connect_adapter_if_begin(@adapter)
-    end
-    it "should delegate calls to [a method we have]_unless_[state](adapter) to [a method we have](adapter) if state of adapter is not [state]" do
-      @transaction.should_receive(:state_for).with(@adapter).and_return(:none)
-      @transaction.should_receive(:connect_adapter).with(@adapter)
-      @transaction.connect_adapter_unless_begin(@adapter)
-    end
-    it "should not delegate calls to [a method we have]_unless_[state](adapter) to [a method we have](adapter) if state of adapter is [state]" do
-      @transaction.should_receive(:state_for).with(@adapter).and_return(:begin)
-      @transaction.should_not_receive(:connect_adapter).with(@adapter)
-      @transaction.connect_adapter_unless_begin(@adapter)
-    end
-    it "should not delegate calls whose first argument is not a DataMapper::Adapters::AbstractAdapter" do
-      lambda do @transaction.connect_adapter_unless_begin("plur") end.should raise_error
-    end
-    it "should not delegate calls that do not look like an if or unless followed by a state" do
-      lambda do @transaction.connect_adapter_unless_hepp(@adapter) end.should raise_error
-      lambda do @transaction.connect_adapter_when_begin(@adapter) end.should raise_error
-    end
-    it "should not delegate calls that we can not respond to" do
-      lambda do @transaction.connect_adapters_unless_begin(@adapter) end.should raise_error
-      lambda do @transaction.connect_adapters_if_begin(@adapter) end.should raise_error
-    end
-  end
-  it "should be able to produce the connection for an adapter" do
-    @transaction_primitive.stub!(:begin)
-    @repository_transaction_primitive.stub!(:begin)
-    @transaction = DataMapper::Transaction.new(@adapter, @repository)
-    @transaction.begin
-    @transaction.primitive_for(@adapter).should == @transaction_primitive
-  end
-  describe "#each_adapter" do
-    before :each do
-      @transaction = DataMapper::Transaction.new(@adapter, @repository)
-      @adapter.should_receive(:is_a?).any_number_of_times.with(any_args).and_return(false)
-      @adapter.should_receive(:is_a?).any_number_of_times.with(no_args).and_return(false)
-      @adapter.should_receive(:is_a?).any_number_of_times.with(Regexp).and_return(false)
-      @repository_adapter.should_receive(:is_a?).any_number_of_times.with(any_args).and_return(false)
-      @repository_adapter.should_receive(:is_a?).any_number_of_times.with(no_args).and_return(false)
-      @repository_adapter.should_receive(:is_a?).any_number_of_times.with(Regexp).and_return(false)
-    end
-    it "should send the first argument to itself once for each adapter" do
-      @transaction.should_receive(:plupp).with(@adapter)
-      @transaction.should_receive(:plupp).with(@repository_adapter)
-      @transaction.instance_eval do each_adapter(:plupp, [:plur]) end
-    end
-    it "should stop sending if any call raises an exception, then send each element of the second argument to itself with each adapter as argument" do
-      a1 = @repository_adapter
-      a2 = @adapter
-      @transaction.adapters.instance_eval do
-        @a1 = a1
-        @a2 = a2
-        def each(&block)
-          yield(@a1, :none)
-          yield(@a2, :none)
-        end
-      end
-      @transaction.should_receive(:plupp).with(@repository_adapter).and_throw(Exception.new("test error - dont mind me"))
-      @transaction.should_not_receive(:plupp).with(@adapter)
-      @transaction.should_receive(:plur).with(@adapter)
-      @transaction.should_receive(:plur).with(@repository_adapter)
-      lambda do @transaction.instance_eval do each_adapter(:plupp, [:plur]) end end.should raise_error(Exception, /test error - dont mind me/)
-    end
-    it "should send each element of the second argument to itself with each adapter as argument even if exceptions occur in the process" do
-      a1 = @repository_adapter
-      a2 = @adapter
-      @transaction.adapters.instance_eval do
-        @a1 = a1
-        @a2 = a2
-        def each(&block)
-          yield(@a1, :none)
-          yield(@a2, :none)
-        end
-      end
-      @transaction.should_receive(:plupp).with(@repository_adapter).and_throw(Exception.new("test error - dont mind me"))
-      @transaction.should_not_receive(:plupp).with(@adapter)
-      @transaction.should_receive(:plur).with(@adapter).and_throw(Exception.new("another test error"))
-      @transaction.should_receive(:plur).with(@repository_adapter).and_throw(Exception.new("yet another error"))
-      lambda do @transaction.instance_eval do each_adapter(:plupp, [:plur]) end end.should raise_error(Exception, /test error - dont mind me/)
-    end
-  end
-  it "should be able to return the state for a given adapter" do
-    @transaction = DataMapper::Transaction.new(@adapter, @repository)
-    a1 = @adapter
-    a2 = @repository_adapter
-    @transaction.instance_eval do state_for(a1) end.should == :none
-    @transaction.instance_eval do state_for(a2) end.should == :none
-    @transaction.instance_eval do @adapters[a1] = :begin end
-    @transaction.instance_eval do state_for(a1) end.should == :begin
-    @transaction.instance_eval do state_for(a2) end.should == :none
-  end
-  describe "#do_adapter" do
-    before :each do
-      @transaction = DataMapper::Transaction.new(@adapter, @repository)
-      @adapter.should_receive(:is_a?).any_number_of_times.with(any_args).and_return(false)
-      @adapter.should_receive(:is_a?).any_number_of_times.with(no_args).and_return(false)
-      @adapter.should_receive(:is_a?).any_number_of_times.with(Regexp).and_return(false)
-    end
-    it "should raise if there is no connection for the adapter" do
-      a1 = @adapter
-      lambda do @transaction.instance_eval do do_adapter(a1, :ping, :pong) end end.should raise_error(Exception, /No primitive/)
-    end
-    it "should raise if the adapter has the wrong state" do
-      @transaction_primitive.stub!(:begin)
-      @repository_transaction_primitive.stub!(:begin)
-      @transaction.begin
-      a1 = @adapter
-      @adapter.should_not_receive(:ping_transaction).with(@transaction)
-      lambda do @transaction.instance_eval do do_adapter(a1, :ping, :pong) end end.should raise_error(Exception, /Illegal state/)
-    end
-    it "should delegate to the adapter if the connection exists and we have the right state" do
-      @transaction_primitive.stub!(:begin)
-      @repository_transaction_primitive.stub!(:begin)
-      @transaction.begin
-      a1 = @adapter
-      @transaction_primitive.should_receive(:ping)
-      @transaction.instance_eval do do_adapter(a1, :ping, :begin) end
-    end
-  end
-  describe "#connect_adapter" do
-    before :each do
-      @other_adapter = mock("adapter")
-      @other_adapter.should_receive(:is_a?).any_number_of_times.with(Array).and_return(false)
-      @other_adapter.should_receive(:is_a?).any_number_of_times.with(DataMapper::Adapters::AbstractAdapter).and_return(true)
-      @transaction = DataMapper::Transaction.new(@other_adapter)
-    end
-    it "should be able to connect an adapter" do
-      a1 = @other_adapter
-      @other_adapter.should_receive(:transaction_primitive).and_return(@transaction_primitive)
-      @transaction.instance_eval do connect_adapter(a1) end
-      @transaction.transaction_primitives[@other_adapter].should == @transaction_primitive
-    end
-  end
-  describe "#close adapter" do
-    before :each do
-      @other_adapter = mock("adapter")
-      @other_adapter.should_receive(:is_a?).any_number_of_times.with(Array).and_return(false)
-      @other_adapter.should_receive(:is_a?).any_number_of_times.with(DataMapper::Adapters::AbstractAdapter).and_return(true)
-      @transaction = DataMapper::Transaction.new(@other_adapter)
-    end
-    it "should be able to close the connection of an adapter" do
-      a1 = @other_adapter
-      @transaction_primitive.should_receive(:close)
-      @other_adapter.should_receive(:transaction_primitive).and_return(@transaction_primitive)
-      @transaction.instance_eval do connect_adapter(a1) end
-      @transaction.transaction_primitives[@other_adapter].should == @transaction_primitive
-      @transaction.instance_eval do close_adapter(a1) end
-      @transaction.transaction_primitives[@other_adapter].should == nil
-    end
-  end
-  describe "the transaction operation methods" do
-    before :each do
-      @other_adapter = mock("adapter")
-      @other_adapter.should_receive(:is_a?).any_number_of_times.with(Array).and_return(false)
-      @other_adapter.should_receive(:is_a?).any_number_of_times.with(DataMapper::Adapters::AbstractAdapter).and_return(true)
-      @other_adapter.should_receive(:is_a?).any_number_of_times.with(any_args).and_return(false)
-      @other_adapter.should_receive(:is_a?).any_number_of_times.with(no_args).and_return(false)
-      @other_adapter.should_receive(:is_a?).any_number_of_times.with(Regexp).and_return(false)
-      @transaction = DataMapper::Transaction.new(@other_adapter)
-    end
-    it "should only allow adapters in state :none to begin" do
-      a1 = @other_adapter
-      @transaction.should_receive(:do_adapter).with(@other_adapter, :begin, :none)
-      @transaction.instance_eval do begin_adapter(a1) end
-    end
-    it "should only allow adapters in state :begin to prepare" do
-      a1 = @other_adapter
-      @transaction.should_receive(:do_adapter).with(@other_adapter, :prepare, :begin)
-      @transaction.instance_eval do prepare_adapter(a1) end
-    end
-    it "should only allow adapters in state :prepare to commit" do
-      a1 = @other_adapter
-      @transaction.should_receive(:do_adapter).with(@other_adapter, :commit, :prepare)
-      @transaction.instance_eval do commit_adapter(a1) end
-    end
-    it "should only allow adapters in state :begin to rollback" do
-      a1 = @other_adapter
-      @transaction.should_receive(:do_adapter).with(@other_adapter, :rollback, :begin)
-      @transaction.instance_eval do rollback_adapter(a1) end
-    end
-    it "should only allow adapters in state :prepare to rollback_prepared" do
-      a1 = @other_adapter
-      @transaction.should_receive(:do_adapter).with(@other_adapter, :rollback_prepared, :prepare)
-      @transaction.instance_eval do rollback_prepared_adapter(a1) end
-    end
-    it "should do delegate properly for rollback_and_close" do
-      a1 = @other_adapter
-      @transaction.should_receive(:rollback_adapter).with(@other_adapter)
-      @transaction.should_receive(:close_adapter).with(@other_adapter)
-      @transaction.instance_eval do rollback_and_close_adapter(a1) end
-    end
-    it "should do delegate properly for rollback_prepared_and_close" do
-      a1 = @other_adapter
-      @transaction.should_receive(:rollback_prepared_adapter).with(@other_adapter)
-      @transaction.should_receive(:close_adapter).with(@other_adapter)
-      @transaction.instance_eval do rollback_prepared_and_close_adapter(a1) end
-    end
-  end
-end