sam-dm-core 0.9.6

data/spec/unit/adapters/adapter_shared_spec.rb

@@ -0,0 +1,15 @@
+
+describe "a DataMapper Adapter", :shared => true do
+
+  it "should initialize the connection uri" do
+    new_adapter = @adapter.class.new(:default, Addressable::URI.parse('some://uri/string'))
+    new_adapter.instance_variable_get('@uri').to_s.should == Addressable::URI.parse('some://uri/string').to_s
+  end
+
+  %w{create read_many read_one update delete create_model_storage alter_model_storage destroy_model_storage create_property_storage alter_property_storage destroy_property_storage} .each do |meth|
+    it "should have a #{meth} method" do
+      @adapter.should respond_to(meth.intern)
+    end
+  end
+
+end

data/spec/unit/adapters/data_objects_adapter_spec.rb

@@ -0,0 +1,628 @@
+require 'monitor'
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+require DataMapper.root / 'spec' / 'unit' / 'adapters' / 'adapter_shared_spec'
+
+# TODO: make a shared adapter spec for all the DAO objects to adhere to
+
+describe DataMapper::Adapters::DataObjectsAdapter do
+  before :all do
+    class Cheese
+      include DataMapper::Resource
+      property :id, Serial
+      property :name, String, :nullable => false
+      property :color, String, :default => 'yellow'
+      property :notes, String, :length => 100, :lazy => true
+    end
+  end
+
+  before do
+    @uri     = Addressable::URI.parse('mock://localhost')
+    @adapter = DataMapper::Adapters::DataObjectsAdapter.new(:default, @uri)
+  end
+
+  it_should_behave_like 'a DataMapper Adapter'
+
+  describe "#find_by_sql" do
+
+    before do
+      class Plupp
+        include DataMapper::Resource
+        property :id, Integer, :key => true
+        property :name, String
+      end
+    end
+
+    it "should be added to DataMapper::Model" do
+      DataMapper::Model.instance_methods.include?("find_by_sql").should == true
+      Plupp.should respond_to(:find_by_sql)
+    end
+
+    describe "when called" do
+
+      before do
+        @reader = mock("reader")
+        @reader.stub!(:next!).and_return(false)
+        @reader.stub!(:close)
+        @connection = mock("connection")
+        @connection.stub!(:close)
+        @command = mock("command")
+        @adapter = Plupp.repository.adapter
+        @repository = Plupp.repository
+        @repository.stub!(:adapter).and_return(@adapter)
+        @adapter.stub!(:create_connection).and_return(@connection)
+        @adapter.should_receive(:is_a?).any_number_of_times.with(DataMapper::Adapters::DataObjectsAdapter).and_return(true)
+      end
+
+      it "should accept a single String argument with or without options hash" do
+        @connection.should_receive(:create_command).twice.with("SELECT * FROM plupps").and_return(@command)
+        @command.should_receive(:execute_reader).twice.and_return(@reader)
+        Plupp.should_receive(:repository).any_number_of_times.and_return(@repository)
+        Plupp.should_receive(:repository).any_number_of_times.with(:plupp_repo).and_return(@repository)
+        Plupp.find_by_sql("SELECT * FROM plupps").to_a
+        Plupp.find_by_sql("SELECT * FROM plupps", :repository => :plupp_repo).to_a
+      end
+
+      it "should accept an Array argument with or without options hash" do
+        @connection.should_receive(:create_command).twice.with("SELECT * FROM plupps WHERE plur = ?").and_return(@command)
+        @command.should_receive(:execute_reader).twice.with("my pretty plur").and_return(@reader)
+        Plupp.should_receive(:repository).any_number_of_times.and_return(@repository)
+        Plupp.should_receive(:repository).any_number_of_times.with(:plupp_repo).and_return(@repository)
+        Plupp.find_by_sql(["SELECT * FROM plupps WHERE plur = ?", "my pretty plur"]).to_a
+        Plupp.find_by_sql(["SELECT * FROM plupps WHERE plur = ?", "my pretty plur"], :repository => :plupp_repo).to_a
+      end
+
+      it "should accept a Query argument with or without options hash" do
+        @connection.should_receive(:create_command).twice.with('SELECT "name" FROM "plupps" WHERE ("name" = ?) ORDER BY "id"').and_return(@command)
+        @command.should_receive(:execute_reader).twice.with('my pretty plur').and_return(@reader)
+        Plupp.should_receive(:repository).any_number_of_times.and_return(@repository)
+        Plupp.should_receive(:repository).any_number_of_times.with(:plupp_repo).and_return(@repository)
+        Plupp.find_by_sql(DataMapper::Query.new(@repository, Plupp, "name" => "my pretty plur", :fields => ["name"])).to_a
+        Plupp.find_by_sql(DataMapper::Query.new(@repository, Plupp, "name" => "my pretty plur", :fields => ["name"]), :repository => :plupp_repo).to_a
+      end
+
+      it "requires a Repository that is a DataObjectsRepository to work" do
+        non_do_adapter = mock("non do adapter")
+        non_do_repo = mock("non do repo")
+        non_do_repo.stub!(:adapter).and_return(non_do_adapter)
+        Plupp.should_receive(:repository).any_number_of_times.with(:plupp_repo).and_return(non_do_repo)
+        Proc.new do
+          Plupp.find_by_sql(:repository => :plupp_repo)
+        end.should raise_error(Exception, /DataObjectsAdapter/)
+      end
+
+      it "requires some kind of query to work at all" do
+        Plupp.should_receive(:repository).any_number_of_times.with(:plupp_repo).and_return(@repository)
+        Proc.new do
+          Plupp.find_by_sql(:repository => :plupp_repo)
+        end.should raise_error(Exception, /requires a query/)
+      end
+
+    end
+
+  end
+
+  describe '#uri options' do
+    it 'should transform a fully specified option hash into a URI' do
+      options = {
+        :adapter => 'mysql',
+        :host => 'davidleal.com',
+        :username => 'me',
+        :password => 'mypass',
+        :port => 5000,
+        :database => 'you_can_call_me_al',
+        :socket => 'nosock'
+      }
+
+      adapter = DataMapper::Adapters::DataObjectsAdapter.new(:spec, options)
+      adapter.uri.should ==
+        Addressable::URI.parse("mysql://me:mypass@davidleal.com:5000/you_can_call_me_al?socket=nosock")
+    end
+
+    it 'should transform a minimal options hash into a URI' do
+      options = {
+        :adapter => 'mysql',
+        :database => 'you_can_call_me_al'
+      }
+
+      adapter = DataMapper::Adapters::DataObjectsAdapter.new(:spec, options)
+      adapter.uri.should == Addressable::URI.parse("mysql:you_can_call_me_al")
+    end
+
+    it 'should accept the uri when no overrides exist' do
+      uri = Addressable::URI.parse("protocol:///")
+      DataMapper::Adapters::DataObjectsAdapter.new(:spec, uri).uri.should == uri
+    end
+  end
+
+  describe '#create' do
+    before do
+      @result = mock('result', :to_i => 1, :insert_id => 1)
+
+      @adapter.stub!(:execute).and_return(@result)
+      @adapter.stub!(:supports_returning?).and_return(false)
+
+      @property    = mock('property', :kind_of? => true, :serial? => true, :name => :property, :field => 'property', :custom? => false, :typecast => 'bind value')
+      @properties  = [ @property ]
+      @bind_values = [ 'bind value' ]
+      @attributes  = mock('attributes', :keys => @properties, :values => @bind_values)
+      @model       = mock('model', :kind_of? => true, :key => [ @property ], :storage_name => 'models')
+      @resource    = mock('resource', :model => @model, :dirty_attributes => @attributes)
+
+      @property.stub!(:set!).and_return(@resource)
+
+      @statement   = 'INSERT INTO "models" ("property") VALUES (?)'
+    end
+
+    def do_create
+      @adapter.create([ @resource ])
+    end
+
+    it 'should use only dirty properties' do
+      @resource.should_receive(:dirty_attributes).with(no_args).and_return(@attributes)
+      do_create.should == 1
+    end
+
+    it 'should use the bind values' do
+      @attributes.should_receive(:values).with(no_args).and_return(@bind_values)
+
+      @adapter.should_receive(:execute).with(@statement, *@bind_values).and_return(@result)
+
+      do_create.should == 1
+    end
+
+    it 'should generate an SQL statement when supports_returning? is true' do
+      @property.should_receive(:serial?).with(no_args).and_return(true)
+      @adapter.should_receive(:supports_returning?).with(no_args).and_return(true)
+
+      @statement = 'INSERT INTO "models" ("property") VALUES (?) RETURNING "property"'
+      @adapter.should_receive(:execute).with(@statement, 'bind value').and_return(@result)
+
+      do_create.should == 1
+    end
+
+    it 'should generate an SQL statement when supports_default_values? is true' do
+      @bind_values.clear
+      @properties.clear
+      @adapter.should_receive(:supports_default_values?).with(no_args).and_return(true)
+
+      @statement = 'INSERT INTO "models" DEFAULT VALUES'
+      @adapter.should_receive(:execute).with(@statement).and_return(@result)
+
+      do_create.should == 1
+    end
+
+    it 'should generate an SQL statement when supports_default_values? is false' do
+      @bind_values.clear
+      @properties.clear
+      @adapter.should_receive(:supports_default_values?).with(no_args).and_return(false)
+
+      @statement = 'INSERT INTO "models" () VALUES ()'
+      @adapter.should_receive(:execute).with(@statement).and_return(@result)
+
+      do_create.should == 1
+    end
+
+    it 'should return 0 if no rows created' do
+      @result.should_receive(:to_i).with(no_args).and_return(0)
+      do_create.should == 0
+    end
+
+    it 'should return 1 if number of rows created is 1' do
+      @result.should_receive(:to_i).with(no_args).and_return(1)
+      do_create.should == 1
+    end
+
+    it 'should set the resource primary key if the model key size is 1 and the key is serial' do
+      @model.key.size.should == 1
+      @property.should_receive(:serial?).and_return(true)
+      @result.should_receive(:insert_id).and_return(777)
+      @property.should_receive(:set!).with(@resource, 777)
+      do_create.should == 1
+    end
+  end
+
+  [ :read_many, :read_one ].each do |method|
+    describe "##{method}" do
+      before do
+        @key       = mock('key')
+        @model     = mock('model', :key => @key, :storage_name => 'models', :relationships => {})
+        @primitive = mock('primitive')
+        @property  = mock('property', :kind_of? => true, :model => @model, :field => 'property', :primitive => @primitive)
+
+        @child_model     = @model
+        @parent_model    = mock('parent model', :storage_name => 'parents')
+        @parent_property = mock('parent id', :kind_of? => true, :model => @parent_model, :field => 'id')
+
+        @child_key    = [ @property ]
+        @parent_key   = [ @parent_property ]
+        @relationship = mock('relationship', :child_model => @child_model, :parent_model => @parent_model, :child_key => @child_key, :parent_key => @parent_key)
+        @links        = [ @relationship ]
+
+        @fields      = [ @property ]
+        @bind_values = [ 'bind value' ]
+        @conditions  = [ [ :eql, @property, @bind_values[0] ] ]
+
+        @direction = mock('direction', :property => @property, :direction => :desc)
+        @order     = [ @direction ]
+
+        @query = mock('query', :model => @model, :kind_of? => true, :links => @links, :fields => @fields, :conditions => @conditions, :order => @order, :limit => 111, :offset => 222, :bind_values => @bind_values)
+        @query.should_receive(:unique?).with(no_args).and_return(false)
+
+        @reader     = mock('reader', :close => true, :next! => false)
+        @command    = mock('command', :set_types => nil, :execute_reader => @reader)
+        @connection = mock('connection', :close => true, :create_command => @command)
+
+        DataObjects::Connection.stub!(:new).and_return(@connection)
+        DataMapper::Query::Direction.stub!(:===).and_return(true)
+      end
+
+      if method == :read_one
+        before do
+          @query.should_receive(:limit).with(no_args).twice.and_return(1)
+
+          @values = @bind_values.dup
+
+          @reader.should_receive(:next!).with(no_args).and_return(true)
+          @reader.should_receive(:values).with(no_args).and_return(@values)
+
+          @resource = mock('resource')
+          @resource.should_receive(:kind_of?).with(DataMapper::Resource).any_number_of_times.and_return(true)
+
+          @model.should_receive(:load).with(@values, @query).and_return(@resource)
+
+          @statement = 'SELECT "models"."property" FROM "models" INNER JOIN "parents" ON ("parents"."id" = "models"."property") WHERE ("models"."property" = ?) ORDER BY "models"."property" DESC LIMIT 1 OFFSET 222'
+        end
+
+        define_method(:do_read) do
+          resource = @adapter.read_one(@query)
+          resource.should == @resource
+          resource
+        end
+      elsif method == :read_many
+        before do
+          @statement = 'SELECT "models"."property" FROM "models" INNER JOIN "parents" ON ("parents"."id" = "models"."property") WHERE ("models"."property" = ?) ORDER BY "models"."property" DESC LIMIT 111 OFFSET 222'
+        end
+
+        define_method(:do_read) do
+          collection = @adapter.read_many(@query)
+          collection.to_a
+          collection
+        end
+      end
+
+      it 'should use the bind values' do
+        @command.should_receive(:execute_reader).with(*@bind_values).and_return(@reader)
+        do_read
+      end
+
+      it 'should generate an SQL statement' do
+        @connection.should_receive(:create_command).with(@statement).and_return(@command)
+        do_read
+      end
+
+      it 'should generate an SQL statement with composite keys' do
+        other_property = mock('other property', :kind_of? => true)
+        other_property.should_receive(:field).with(:default).and_return('other')
+        other_property.should_receive(:model).with(no_args).and_return(@model)
+
+        other_value = 'other value'
+        @bind_values << other_value
+        @conditions << [ :eql, other_property, other_value ]
+
+        @statement = %[SELECT "models"."property" FROM "models" INNER JOIN "parents" ON ("parents"."id" = "models"."property") WHERE ("models"."property" = ?) AND ("models"."other" = ?) ORDER BY "models"."property" DESC LIMIT #{method == :read_one ? '1' : '111'} OFFSET 222]
+        @query.should_receive(:conditions).with(no_args).twice.and_return(@conditions)
+
+        @connection.should_receive(:create_command).with(@statement).and_return(@command)
+
+        do_read
+      end
+
+      it 'should set the return types to the property primitives' do
+        @command.should_receive(:set_types).with([ @primitive ])
+        do_read
+      end
+
+      it 'should close the reader' do
+        @reader.should_receive(:close).with(no_args)
+        do_read
+      end
+
+      it 'should close the connection' do
+        @connection.should_receive(:close).with(no_args)
+        do_read
+      end
+
+      if method == :read_one
+        it 'should return a DataMapper::Resource' do
+          do_read.should == be_kind_of(DataMapper::Resource)
+        end
+      else
+        it 'should return a DataMapper::Collection' do
+          do_read.should be_kind_of(DataMapper::Collection)
+        end
+      end
+    end
+  end
+
+  describe '#update' do
+    before do
+      @result = mock('result', :to_i => 1)
+
+      @adapter.stub!(:execute).and_return(@result)
+
+      @values      = %w[ new ]
+      @model       = mock('model', :storage_name => 'models')
+      @property    = mock('property', :kind_of? => true, :field => 'property')
+      @bind_values = [ 'bind value' ]
+      @conditions  = [ [ :eql, @property, @bind_values[0] ] ]
+      @attributes  = mock('attributes', :kind_of? => true, :empty? => false, :keys => [ @property ], :values => @values)
+      @query       = mock('query', :kind_of? => true, :model => @model, :links => [], :conditions => @conditions, :bind_values => @bind_values)
+      @statement   = 'UPDATE "models" SET "property" = ? WHERE ("property" = ?)'
+    end
+
+    def do_update
+      @adapter.update(@attributes, @query)
+    end
+
+    it 'should use the bind values' do
+      @attributes.should_receive(:values).with(no_args).and_return(@values)
+      @query.should_receive(:bind_values).with(no_args).and_return(@bind_values)
+
+      @adapter.should_receive(:execute).with(@statement, *@values + @bind_values).and_return(@result)
+
+      do_update.should == 1
+    end
+
+    it 'should generate an SQL statement' do
+      other_property = mock('other property', :kind_of? => true)
+      other_property.should_receive(:field).with(:default).and_return('other')
+      other_property.should_receive(:model).with(no_args).and_return(@model)
+
+      other_value = 'other value'
+      @bind_values << other_value
+      @conditions << [ :eql, other_property, other_value ]
+
+      @query.should_receive(:conditions).with(no_args).twice.and_return(@conditions)
+
+      @statement   = 'UPDATE "models" SET "property" = ? WHERE ("property" = ?) AND ("other" = ?)'
+      @adapter.should_receive(:execute).with(@statement, *%w[ new ] + @bind_values).and_return(@result)
+
+      do_update.should == 1
+    end
+
+    it 'should return 0 if no rows updated' do
+      @result.should_receive(:to_i).with(no_args).and_return(0)
+      do_update.should == 0
+    end
+
+    it 'should return 1 if number of rows updated is 1' do
+      @result.should_receive(:to_i).with(no_args).and_return(1)
+      do_update.should == 1
+    end
+  end
+
+  describe '#delete' do
+    before do
+      @result = mock('result', :to_i => 1)
+
+      @adapter.stub!(:execute).and_return(@result)
+
+      @model       = mock('model', :storage_name => 'models')
+      @property    = mock('property', :kind_of? => true, :field => 'property')
+      @bind_values = [ 'bind value' ]
+      @conditions  = [ [ :eql, @property, @bind_values[0] ] ]
+      @query       = mock('query', :kind_of? => true, :model => @model, :links => [], :conditions => @conditions, :bind_values => @bind_values)
+      @resource    = mock('resource', :to_query => @query)
+      @statement   = 'DELETE FROM "models" WHERE ("property" = ?)'
+    end
+
+    def do_delete
+      @adapter.delete(@resource.to_query(@repository))
+    end
+
+    it 'should use the bind values' do
+      @query.should_receive(:bind_values).with(no_args).and_return(@bind_values)
+
+      @adapter.should_receive(:execute).with(@statement, *@bind_values).and_return(@result)
+
+      do_delete.should == 1
+    end
+
+    it 'should generate an SQL statement' do
+      other_property = mock('other property', :kind_of? => true)
+      other_property.should_receive(:field).with(:default).and_return('other')
+      other_property.should_receive(:model).with(no_args).and_return(@model)
+
+      other_value = 'other value'
+      @bind_values << other_value
+      @conditions << [ :eql, other_property, other_value ]
+
+      @query.should_receive(:conditions).with(no_args).twice.and_return(@conditions)
+
+      @statement = 'DELETE FROM "models" WHERE ("property" = ?) AND ("other" = ?)'
+      @adapter.should_receive(:execute).with(@statement, *@bind_values).and_return(@result)
+
+      do_delete.should == 1
+    end
+
+    it 'should return 0 if no rows deleted' do
+      @result.should_receive(:to_i).with(no_args).and_return(0)
+      do_delete.should == 0
+    end
+
+    it 'should return 1 if number of rows deleted is 1' do
+      @result.should_receive(:to_i).with(no_args).and_return(1)
+      do_delete.should == 1
+    end
+  end
+
+  describe "when upgrading tables" do
+    it "should raise NotImplementedError when #storage_exists? is called" do
+      lambda { @adapter.storage_exists?("cheeses") }.should raise_error(NotImplementedError)
+    end
+
+    describe "#upgrade_model_storage" do
+      it "should call #create_model_storage" do
+        @adapter.should_receive(:create_model_storage).with(repository, Cheese).and_return(true)
+        @adapter.upgrade_model_storage(repository, Cheese).should == Cheese.properties
+      end
+
+      it "should check if all properties of the model have columns if the table exists" do
+        @adapter.should_receive(:field_exists?).with("cheeses", "id").and_return(true)
+        @adapter.should_receive(:field_exists?).with("cheeses", "name").and_return(true)
+        @adapter.should_receive(:field_exists?).with("cheeses", "color").and_return(true)
+        @adapter.should_receive(:field_exists?).with("cheeses", "notes").and_return(true)
+        @adapter.should_receive(:storage_exists?).with("cheeses").and_return(true)
+        @adapter.upgrade_model_storage(repository, Cheese).should == []
+      end
+
+      it "should create and execute add column statements for columns that dont exist" do
+        @adapter.should_receive(:field_exists?).with("cheeses", "id").and_return(true)
+        @adapter.should_receive(:field_exists?).with("cheeses", "name").and_return(true)
+        @adapter.should_receive(:field_exists?).with("cheeses", "color").and_return(true)
+        @adapter.should_receive(:field_exists?).with("cheeses", "notes").and_return(false)
+        @adapter.should_receive(:storage_exists?).with("cheeses").and_return(true)
+        connection = mock("connection")
+        connection.should_receive(:close)
+        @adapter.should_receive(:create_connection).and_return(connection)
+        statement = mock("statement")
+        command = mock("command")
+        result = mock("result")
+        command.should_receive(:execute_non_query).and_return(result)
+        connection.should_receive(:create_command).with(statement).and_return(command)
+        @adapter.should_receive(:alter_table_add_column_statement).with("cheeses",
+                                                                             {
+                                                                               :nullable? => true,
+                                                                               :name => "notes",
+                                                                               :serial? => false,
+                                                                               :primitive => "VARCHAR",
+                                                                               :size => 100
+                                                                             }).and_return(statement)
+        @adapter.upgrade_model_storage(repository, Cheese).should == [Cheese.notes]
+      end
+    end
+  end
+
+  describe '#execute' do
+    before do
+      @mock_command = mock('Command', :execute_non_query => nil)
+      @mock_db = mock('DB Connection', :create_command => @mock_command, :close => true)
+
+      @adapter.stub!(:create_connection).and_return(@mock_db)
+    end
+
+    it 'should #create_command from the sql passed' do
+      @mock_db.should_receive(:create_command).with('SQL STRING').and_return(@mock_command)
+      @adapter.execute('SQL STRING')
+    end
+
+    it 'should pass any additional args to #execute_non_query' do
+      @mock_command.should_receive(:execute_non_query).with(:args)
+      @adapter.execute('SQL STRING', :args)
+    end
+
+    it 'should return the result of #execute_non_query' do
+      @mock_command.should_receive(:execute_non_query).and_return(:result_set)
+
+      @adapter.execute('SQL STRING').should == :result_set
+    end
+
+    it 'should log any errors, then re-raise them' do
+      @mock_command.should_receive(:execute_non_query).and_raise("Oh Noes!")
+      DataMapper.logger.should_receive(:error)
+
+      lambda { @adapter.execute('SQL STRING') }.should raise_error("Oh Noes!")
+    end
+
+    it 'should always close the db connection' do
+      @mock_command.should_receive(:execute_non_query).and_raise("Oh Noes!")
+      @mock_db.should_receive(:close)
+
+      lambda { @adapter.execute('SQL STRING') }.should raise_error("Oh Noes!")
+    end
+  end
+
+  describe '#query' do
+    before do
+      @mock_reader = mock('Reader', :fields => ['id', 'UserName', 'AGE'],
+        :values => [1, 'rando', 27],
+        :close => true)
+      @mock_command = mock('Command', :execute_reader => @mock_reader)
+      @mock_db = mock('DB Connection', :create_command => @mock_command, :close => true)
+
+      #make the while loop run exactly once
+      @mock_reader.stub!(:next!).and_return(true, nil)
+      @adapter.stub!(:create_connection).and_return(@mock_db)
+    end
+
+    it 'should #create_command from the sql passed' do
+      @mock_db.should_receive(:create_command).with('SQL STRING').and_return(@mock_command)
+      @adapter.query('SQL STRING')
+    end
+
+    it 'should pass any additional args to #execute_reader' do
+      @mock_command.should_receive(:execute_reader).with(:args).and_return(@mock_reader)
+      @adapter.query('SQL STRING', :args)
+    end
+
+    describe 'returning multiple fields' do
+
+      it 'should underscore the field names as members of the result struct' do
+        @mock_reader.should_receive(:fields).and_return(['id', 'UserName', 'AGE'])
+
+        result = @adapter.query('SQL STRING')
+
+        result.first.members.should == %w{id user_name age}
+      end
+
+      it 'should convert each row into the struct' do
+        @mock_reader.should_receive(:values).and_return([1, 'rando', 27])
+
+        @adapter.query('SQL STRING')
+      end
+
+      it 'should add the row structs into the results array' do
+        results = @adapter.query('SQL STRING')
+
+        results.should be_kind_of(Array)
+
+        row = results.first
+        row.should be_kind_of(Struct)
+
+        row.id.should == 1
+        row.user_name.should == 'rando'
+        row.age.should == 27
+      end
+
+    end
+
+    describe 'returning a single field' do
+
+      it 'should add the value to the results array' do
+        @mock_reader.should_receive(:fields).and_return(['username'])
+        @mock_reader.should_receive(:values).and_return(['rando'])
+
+        results = @adapter.query('SQL STRING')
+
+        results.should be_kind_of(Array)
+        results.first.should == 'rando'
+      end
+
+    end
+
+    it 'should log any errors, then re-raise them' do
+      @mock_command.should_receive(:execute_non_query).and_raise("Oh Noes!")
+      DataMapper.logger.should_receive(:error)
+
+      lambda { @adapter.execute('SQL STRING') }.should raise_error("Oh Noes!")
+    end
+
+    it 'should always close the db connection' do
+      @mock_command.should_receive(:execute_non_query).and_raise("Oh Noes!")
+      @mock_db.should_receive(:close)
+
+      lambda { @adapter.execute('SQL STRING') }.should raise_error("Oh Noes!")
+    end
+  end
+end