dm-core 0.9.11 → 0.10.0

data/spec/lib/logging_helper.rb

@@ -1,18 +0,0 @@
-module LoggingHelper
-  def logger
-    class << DataMapper.logger
-      attr_writer :log
-    end
-
-    old_log = DataMapper.logger.log
-
-    begin
-      StringIO.new('') do |io|
-        DataMapper.logger.log = io
-        yield io
-      end
-    ensure
-      DataMapper.logger.log = old_log
-    end
-  end
-end

data/spec/lib/mock_adapter.rb

@@ -1,27 +0,0 @@
-module DataMapper
-  module Adapters
-    class MockAdapter < DataMapper::Adapters::DataObjectsAdapter
-
-      def create(resources)
-        1
-      end
-
-      def exists?(storage_name)
-        true
-      end
-
-    end
-  end
-end
-
-module DataObjects
-  module Mock
-
-    def self.logger
-    end
-
-    def self.logger=(value)
-    end
-
-  end
-end

data/spec/lib/model_loader.rb

@@ -1,100 +0,0 @@
-# ---
-# Overview
-# ========
-# ModelLoader is a method for loading methods models for specs in a way
-# that will ensure that each spec will be an a pristine state when run.
-#
-# The problem is that if a spec needs to modify a model, the modifications
-# should not carry over to the next spec. As such, all models are
-# destroyed at the end of the spec and reloaded at the start.
-#
-# The second problem is that DataMapper::Resource keeps track
-# of every class that it is included in. This is used for automigration.
-# A number of specs run automigrate, and we don't want all the classes
-# that were defined in other specs to be migrated as well.
-#
-# Usage
-# =====
-#
-# Sets the specified model metaphors to be loaded before each spec and
-# destroyed after each spec in the current example group. This method
-# can be used in a describe block or in a before block.
-#
-# ==== Parameters
-# *metaphor<Symbol>:: The name of the metaphor to load (this is just the filename of
-#               file in specs/models)
-#
-# ==== Example
-#
-# describe "DataMapper::Associations" do
-#
-#   load_models_for_metaphor :zoo, :blog
-#
-#   it "should be awesome" do
-#     Zoo.new.should be_awesome
-#   end
-# end
-module ModelLoader
-
-  def self.included(base)
-    base.extend(ClassMethods)
-    base.class_eval { include InstanceMethods }
-    # base.before(:each) { load_models(:global) }
-    base.after(:each)  { unload_models }
-  end
-
-  module ClassMethods
-
-    def load_models_for_metaphor(*metaphors)
-      before(:each) { load_models_for_metaphor(*metaphors) }
-    end
-
-  end
-
-  module InstanceMethods
-
-    def load_models_for_metaphor(*metaphors)
-      files = metaphors.map { |m| DataMapper.root / "spec" / "models" / "#{m}.rb" }
-
-      klasses = object_space_classes.dup
-      files.each { |file| load file }
-      loaded_models.concat(object_space_classes - klasses)
-    end
-
-    def unload_models
-      while model = loaded_models.pop
-        remove_model(model)
-      end
-    end
-
-    def loaded_models
-      @loaded_models ||= []
-    end
-
-  private
-
-    def object_space_classes
-      klasses = []
-      ObjectSpace.each_object(Class) {|o| klasses << o}
-      klasses
-    end
-
-    def remove_model(klass)
-      DataMapper::Resource.descendants.delete(klass)
-      # Check to see if the model is living inside a module
-      klass_name = klass.to_s
-      if klass_name.index("::")
-        mod = klass_name.match(/(\S+)::/)[1]
-        child_class = klass_name.match(/\S+::(\S+)/)[1]
-
-        Object.const_get(mod).module_eval { remove_const child_class }
-      else
-        Object.module_eval { remove_const klass.to_s }
-      end
-    end
-  end
-end
-
-Spec::Runner.configure do |config|
-  config.include(ModelLoader)
-end

data/spec/lib/publicize_methods.rb

@@ -1,28 +0,0 @@
-class Class
-  def publicize_methods
-    klass = class << self; self; end
-
-    saved_private_class_methods      = klass.private_instance_methods
-    saved_protected_class_methods    = klass.protected_instance_methods
-    saved_private_instance_methods   = self.private_instance_methods
-    saved_protected_instance_methods = self.protected_instance_methods
-
-    self.class_eval do
-      klass.send(:public, *saved_private_class_methods)
-      klass.send(:public, *saved_protected_class_methods)
-      public(*saved_private_instance_methods)
-      public(*saved_protected_instance_methods)
-    end
-
-    begin
-      yield
-    ensure
-      self.class_eval do
-        klass.send(:private, *saved_private_class_methods)
-        klass.send(:protected, *saved_protected_class_methods)
-        private(*saved_private_instance_methods)
-        protected(*saved_protected_instance_methods)
-      end
-    end
-  end
-end

data/spec/models/content.rb

@@ -1,16 +0,0 @@
-module Content
-  class Dialect
-    include DataMapper::Resource
-
-    property :id,   Serial
-    property :name, String
-    property :code, String
-  end
-
-  class Locale
-    include DataMapper::Resource
-
-    property :id,   Serial
-    property :name, String
-  end
-end

data/spec/models/vehicles.rb

@@ -1,34 +0,0 @@
-# ==========================
-# Used for Association specs
-# ---
-# These models will probably
-# end up removed. So, I wouldn't
-# use this metaphor
-class Vehicle
-  include DataMapper::Resource
-
-  property :id, Serial
-  property :name, String
-
-  class << self
-    attr_accessor :mock_relationship
-  end
-end
-
-class Manufacturer
-  include DataMapper::Resource
-
-  property :id, Serial
-  property :name, String
-
-  class << self
-    attr_accessor :mock_relationship
-  end
-end
-
-class Supplier
-  include DataMapper::Resource
-
-  property :id, Serial
-  property :name, String
-end

data/spec/models/zoo.rb

@@ -1,48 +0,0 @@
-class Zoo
-  include DataMapper::Resource
-
-  property :id,           Serial
-  property :name,         String
-  property :description,  Text
-  property :inception,    DateTime
-  property :open,         Boolean,  :default => false
-  property :size,         Integer
-  property :mission,      Text, :writer => :protected
-
-  has n, :animals
-
-  def to_s
-    name
-  end
-end
-
-class Species
-  include DataMapper::Resource
-
-  property :id,             Serial
-  property :name,           String
-  property :classification, String, :reader => :private
-
-  has n, :animals
-end
-
-class Animal
-  include DataMapper::Resource
-
-  property :id,   Serial
-  property :name, String
-
-  belongs_to :zoo
-  belongs_to :species
-  belongs_to :keeper
-end
-
-class Employee
-  include DataMapper::Resource
-
-  property :name, String, :key => true
-end
-
-class Keeper < Employee
-  has n, :animals
-end

data/spec/unit/adapters/abstract_adapter_spec.rb

@@ -1,133 +0,0 @@
-require 'monitor'
-require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'adapters', 'adapter_shared_spec'))
-
-describe DataMapper::Adapters::AbstractAdapter do
-
-  before do
-    @adapter = DataMapper::Adapters::AbstractAdapter.new(:default, 'mock_uri_string')
-  end
-
-  it_should_behave_like 'a DataMapper Adapter'
-
-  describe "when handling transactions" do
-    before :each do
-      @transaction = DataMapper::Transaction.new(@adapter)
-    end
-    it "should be able to push and pop transactions on the current stack" do
-      @adapter.current_transaction.should == nil
-      @adapter.within_transaction?.should == false
-      @adapter.push_transaction(@transaction)
-      @adapter.current_transaction.should == @transaction
-      @adapter.within_transaction?.should == true
-      @adapter.push_transaction(@transaction)
-      @adapter.current_transaction.should == @transaction
-      @adapter.within_transaction?.should == true
-      @adapter.pop_transaction
-      @adapter.current_transaction.should == @transaction
-      @adapter.within_transaction?.should == true
-      @adapter.pop_transaction
-      @adapter.current_transaction.should == nil
-      @adapter.within_transaction?.should == false
-    end
-    it "should let each Thread have its own transaction stack" do
-      lock = Monitor.new
-      transaction2 = DataMapper::Transaction.new(@adapter)
-      @adapter.within_transaction?.should == false
-      @adapter.current_transaction.should == nil
-      @adapter.push_transaction(transaction2)
-      @adapter.within_transaction?.should == true
-      @adapter.current_transaction.should == transaction2
-      lock.synchronize do
-        Thread.new do
-          @adapter.within_transaction?.should == false
-          @adapter.current_transaction.should == nil
-          @adapter.push_transaction(@transaction)
-          @adapter.within_transaction?.should == true
-          @adapter.current_transaction.should == @transaction
-          lock.synchronize do
-            @adapter.within_transaction?.should == true
-            @adapter.current_transaction.should == @transaction
-            @adapter.pop_transaction
-            @adapter.within_transaction?.should == false
-            @adapter.current_transaction.should == nil
-          end
-        end
-        @adapter.within_transaction?.should == true
-        @adapter.current_transaction.should == transaction2
-        @adapter.pop_transaction
-        @adapter.within_transaction?.should == false
-        @adapter.current_transaction.should == nil
-      end
-    end
-  end
-
-  it "should raise NotImplementedError when #create is called" do
-    lambda { @adapter.create([ :resource ]) }.should raise_error(NotImplementedError)
-  end
-
-  it "should raise NotImplementedError when #read_many is called" do
-    lambda { @adapter.read_many(:query) }.should raise_error(NotImplementedError)
-  end
-
-  it "should raise NotImplementedError when #read_one is called" do
-    lambda { @adapter.read_one(:query) }.should raise_error(NotImplementedError)
-  end
-
-  it "should raise NotImplementedError when #update is called" do
-    lambda { @adapter.update(:attributes, :query) }.should raise_error(NotImplementedError)
-  end
-
-  it "should raise NotImplementedError when #delete is called" do
-    lambda { @adapter.delete(:query) }.should raise_error(NotImplementedError)
-  end
-
-  it "should raise NotImplementedError when #upgrade_model_storage is called" do
-    lambda { @adapter.upgrade_model_storage(:repository, :resource) }.should raise_error(NotImplementedError)
-  end
-
-  it "should raise NotImplementedError when #storage_exists? is called" do
-    lambda { @adapter.storage_exists?("hehu") }.should raise_error(NotImplementedError)
-  end
-
-  it "should raise NotImplementedError when #create_model_storage is called" do
-    lambda { @adapter.create_model_storage(:repository, :resource) }.should raise_error(NotImplementedError)
-  end
-
-  it "should raise NotImplementedError when #destroy_model_storage is called" do
-    lambda { @adapter.destroy_model_storage(:repository, :resource) }.should raise_error(NotImplementedError)
-  end
-
-  it "should raise NotImplementedError when #alter_model_storage is called" do
-    lambda { @adapter.alter_model_storage(:repository, :resource) }.should raise_error(NotImplementedError)
-  end
-
-  it "should raise NotImplementedError when #create_property_storage is called" do
-    lambda { @adapter.create_property_storage(:repository, :property) }
-  end
-
-  it "should raise NotImplementedError when #destroy_property_storage is called" do
-    lambda { @adapter.destroy_property_storage(:repository, :property) }
-  end
-
-  it "should raise NotImplementedError when #alter_property_storage is called" do
-    lambda { @adapter.alter_property_storage(:repository, :property) }
-  end
-
-  it "should raise NotImplementedError when #transaction_primitive is called" do
-    lambda { @adapter.transaction_primitive }.should raise_error(NotImplementedError)
-  end
-
-  it "should clean out dead threads from @transactions" do
-    @adapter.instance_eval do @transactions end.size.should == 0
-    t = Thread.new do
-      @adapter.push_transaction("plur")
-    end
-    while t.alive?
-      sleep 0.1
-    end
-    @adapter.instance_eval do @transactions end.size.should == 1
-    @adapter.push_transaction("ploj")
-    @adapter.instance_eval do @transactions end.size.should == 1
-  end
-end

data/spec/unit/adapters/adapter_shared_spec.rb

@@ -1,15 +0,0 @@
-
-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

@@ -1,632 +0,0 @@
-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.map { |m| m.to_s }.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
-        if ADAPTER == :mysql
-          @connection.should_receive(:create_command).twice.with('SELECT `name` FROM `plupps` WHERE (`name` = ?) ORDER BY `id`').and_return(@command)
-        else
-          @connection.should_receive(:create_command).twice.with('SELECT "name" FROM "plupps" WHERE ("name" = ?) ORDER BY "id"').and_return(@command)
-        end
-        @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 ==
-        DataObjects::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 == DataObjects::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 == DataObjects::URI.parse(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.map { |m| m.to_s }.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