dm-core 0.9.11 → 0.10.0

data/spec/integration/data_objects_adapter_spec.rb

@@ -1,32 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-if [ HAS_SQLITE3, HAS_MYSQL, HAS_POSTGRES ].include?(ADAPTER)
-  describe DataMapper::Adapters::DataObjectsAdapter, "with #{ADAPTER}" do
-    describe 'a connection' do
-      before do
-        @adapter  = DataMapper::Repository.adapters[ADAPTER]
-        @transaction = DataMapper::Transaction.new(@adapter)
-
-        @command = mock('command', :execute_non_query => nil)
-        @connection = mock('connection', :create_command => @command)
-        DataObjects::Connection.stub!(:new).and_return(@connection)
-      end
-
-      it 'should close automatically when no longer needed' do
-        @connection.should_receive(:close)
-        @adapter.execute('SELECT 1')
-      end
-
-      it 'should not close when a current transaction is active' do
-        @connection.should_receive(:create_command).with('SELECT 1').twice.and_return(@command)
-        @connection.should_not_receive(:close)
-
-        @transaction.begin
-        @transaction.within do
-          @adapter.execute('SELECT 1')
-          @adapter.execute('SELECT 1')
-        end
-      end
-    end
-  end
-end

data/spec/integration/dependency_queue_spec.rb

@@ -1,46 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-describe "DataMapper::DependencyQueue" do
-  before :each do
-    @q = DataMapper::DependencyQueue.new
-    @dependencies = @q.instance_variable_get("@dependencies")
-  end
-
-  describe "#add" do
-    it "should store the supplied callback in @dependencies" do
-      @q.add('MissingConstant') { true }
-      @dependencies['MissingConstant'].first.call.should == true
-    end
-  end
-
-  describe "#resolve!" do
-    describe "(when dependency is not defined)" do
-      it "should not alter @dependencies" do
-        @q.add('MissingConstant') { true }
-        old_dependencies = @dependencies.dup
-        @q.resolve!
-        old_dependencies.should == @dependencies
-      end
-    end
-
-    describe "(when dependency is defined)" do
-      before :each do
-        @q.add('MissingConstant') { |klass| klass.instance_variable_set("@resolved", true) } # add before MissingConstant is loaded
-
-        class ::MissingConstant
-        end
-      end
-
-      it "should execute stored callbacks" do
-        @q.resolve!
-        MissingConstant.instance_variable_get("@resolved").should == true
-      end
-
-      it "should clear @dependencies" do
-        @q.resolve!
-        @dependencies['MissingConstant'].should be_empty
-      end
-    end
-  end
-
-end

data/spec/integration/model_spec.rb

@@ -1,197 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-if ADAPTER
-  module ::ModelSpec
-    class STI
-      include DataMapper::Resource
-
-      def self.default_repository_name
-        ADAPTER
-      end
-
-      property :id,   Serial
-      property :name, String
-      property :type, Discriminator
-    end
-
-    class STIDescendant < STI
-    end
-  end
-
-  describe "DataMapper::Model with #{ADAPTER}" do
-    before do
-      repository(ADAPTER) do
-        ModelSpec::STI.auto_migrate!
-      end
-
-      @planet = DataMapper::Model.new('planet') do
-        def self.default_repository_name; ADAPTER end
-        property :name, String, :key => true
-        property :distance, Integer
-      end
-
-      @moon   = DataMapper::Model.new('moon') do
-        def self.default_repository_name; ADAPTER end
-        property :id, DM::Serial
-        property :name, String
-      end
-
-      @planet.auto_migrate!(ADAPTER)
-      @moon.auto_migrate!(ADAPTER)
-
-      repository(ADAPTER) do
-        @moon.create(:name => "Charon")
-        @moon.create(:name => "Phobos")
-      end
-    end
-
-    describe '.new' do
-      it 'should be able to persist' do
-        repository(ADAPTER) do
-          pluto = @planet.new
-          pluto.name = 'Pluto'
-          pluto.distance = 1_000_000
-          pluto.save
-
-          clone = @planet.get!('Pluto')
-          clone.name.should == 'Pluto'
-          clone.distance.should == 1_000_000
-        end
-      end
-    end
-
-    describe ".get" do
-      include LoggingHelper
-
-      it "should typecast key" do
-        resource = nil
-        lambda {
-          repository(ADAPTER) do
-            resource = @moon.get("1")
-          end
-        }.should_not raise_error
-        resource.should be_kind_of(DataMapper::Resource)
-      end
-
-      it "should use the identity map within a repository block" do
-        logger do |log|
-          repository(ADAPTER) do
-            @moon.get("1")
-            @moon.get(1)
-          end
-          log.readlines.size.should == 1
-        end
-      end
-
-      it "should not use the identity map outside a repository block" do
-        logger do |log|
-          @moon.get(1)
-          @moon.get(1)
-          log.readlines.size.should == 2
-        end
-      end
-    end
-
-    describe ".base_model" do
-      describe "(when called on base model)" do
-        it "should refer to itself" do
-          ModelSpec::STI.base_model.should == ModelSpec::STI
-        end
-      end
-      describe "(when called on descendant model)" do
-        it "should refer to the base model" do
-          ModelSpec::STIDescendant.base_model.should == ModelSpec::STI.base_model
-        end
-      end
-    end
-
-    it 'should provide #load' do
-      ModelSpec::STI.should respond_to(:load)
-    end
-
-    describe '#load' do
-      it 'should load resources with nil discriminator fields' do
-        resource = ModelSpec::STI.create(:name => 'resource')
-        query = ModelSpec::STI.all.query
-        fields = query.fields
-
-        fields.should == ModelSpec::STI.properties(ADAPTER).slice(:id, :name, :type)
-
-        # would blow up prior to fix
-        lambda {
-          ModelSpec::STI.load([ resource.id, resource.name, nil ], query)
-        }.should_not raise_error(NoMethodError)
-      end
-    end
-
-    it { ModelSpec::STI.should respond_to(:copy) }
-
-    ([ :sqlite3, :mysql, :postgres ] - [ ADAPTER ]).each do |alternate|
-      describe '#copy' do
-        describe 'between identical models' do
-          before do
-            ModelSpec::STI.auto_migrate!(alternate)
-
-            ModelSpec::STI.create(:name => 'Record 1')
-            ModelSpec::STI.create(:name => 'Record 2')
-
-            # copy from the default to the alternate repository
-            @return = @resources = ModelSpec::STI.copy(:default, alternate)
-          end
-
-          it 'should return an Enumerable' do
-            @return.should be_a_kind_of(Enumerable)
-          end
-
-          it 'should return Resources' do
-            @return.each { |r| r.should be_a_kind_of(DataMapper::Resource) }
-          end
-
-          it 'should have each Resource set to the expected Repository' do
-            @resources.each { |r| r.repository.name.should == alternate }
-          end
-
-          it 'should create the Resources in the expected Repository' do
-            ModelSpec::STI.all(:repository => repository(alternate)).should == @resources
-          end
-        end
-
-        describe 'between different models' do
-          before do
-            # add an extra property to the alternate model
-            repository(alternate) do
-              ModelSpec::STI.property :status, String, :default => 'new'
-            end
-
-            ModelSpec::STI.auto_migrate!(alternate)
-
-            # add new resources to the alternate repository
-            repository(alternate) do
-              ModelSpec::STI.create(:name => 'Record 1')
-              ModelSpec::STI.create(:name => 'Record 2')
-            end
-
-            # copy from the alternate to the default repository
-            @return = @resources = ModelSpec::STI.copy(alternate, :default)
-          end
-
-          it 'should return an Enumerable' do
-            @return.should be_a_kind_of(Enumerable)
-          end
-
-          it 'should return Resources' do
-            @return.each { |r| r.should be_a_kind_of(DataMapper::Resource) }
-          end
-
-          it 'should have each Resource set to the expected Repository' do
-            @resources.each { |r| r.repository.name.should == :default }
-          end
-
-          it 'should create the Resources in the expected Repository' do
-            ModelSpec::STI.all.should == @resources
-          end
-        end
-      end
-    end
-  end
-end

data/spec/integration/mysql_adapter_spec.rb

@@ -1,85 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-if HAS_MYSQL
-  describe DataMapper::Adapters::MysqlAdapter do
-    before :all do
-      @adapter = repository(:mysql).adapter
-    end
-
-    before :all do
-      class ::Sputnik
-        include DataMapper::Resource
-
-        property :id, Serial
-        property :name, DM::Text
-        property :object, Object
-
-        auto_migrate!(:mysql)
-      end
-    end
-
-    it "should handle Object type" do
-      time = Time.now
-      repository(:mysql) do
-        Sputnik.create(:name => "Sputnik", :object => time)
-        Sputnik.first.object.should == time
-      end
-    end
-
-    describe "auto migrating" do
-      it "#upgrade_model should work" do
-        @adapter.destroy_model_storage(repository(:mysql), Sputnik)
-        @adapter.storage_exists?("sputniks").should == false
-        Sputnik.auto_migrate!(:mysql)
-        @adapter.storage_exists?("sputniks").should == true
-        @adapter.field_exists?("sputniks", "new_prop").should == false
-        Sputnik.property :new_prop, Integer
-        Sputnik.auto_upgrade!(:mysql)
-        @adapter.field_exists?("sputniks", "new_prop").should == true
-      end
-    end
-
-    describe "querying metadata" do
-      it "#storage_exists? should return true for tables that exist" do
-        @adapter.storage_exists?("sputniks").should == true
-      end
-
-      it "#storage_exists? should return false for tables that don't exist" do
-        @adapter.storage_exists?("space turds").should == false
-      end
-
-      it "#field_exists? should return true for columns that exist" do
-        @adapter.field_exists?("sputniks", "name").should == true
-      end
-
-      it "#storage_exists? should return false for tables that don't exist" do
-        @adapter.field_exists?("sputniks", "plur").should == false
-      end
-    end
-
-    describe "handling transactions" do
-      before do
-        @transaction = DataMapper::Transaction.new(@adapter)
-      end
-
-      it "should rollback changes when #rollback_transaction is called" do
-        repository(:mysql) do
-          @transaction.commit do |trans|
-            Sputnik.create(:name => 'my pretty sputnik')
-            trans.rollback
-          end
-          Sputnik.all(:name => 'my pretty sputnik').should be_empty
-        end
-      end
-
-      it "should commit changes when #commit_transaction is called" do
-        repository(:mysql) do
-          @transaction.commit do
-            Sputnik.create(:name => 'my pretty sputnik')
-          end
-          Sputnik.all(:name => 'my pretty sputnik').size.should == 1
-        end
-      end
-    end
-  end
-end

data/spec/integration/postgres_adapter_spec.rb

@@ -1,731 +0,0 @@
-require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
-
-if HAS_POSTGRES
-  describe DataMapper::Adapters::PostgresAdapter do
-    before :all do
-      @adapter = repository(:postgres).adapter
-    end
-
-    describe "auto migrating" do
-      before :all do
-        class ::Sputnik
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, DM::Text
-        end
-      end
-
-      it "#upgrade_model should work" do
-        @adapter.destroy_model_storage(repository(:postgres), Sputnik)
-        @adapter.storage_exists?("sputniks").should be_false
-        Sputnik.auto_migrate!(:postgres)
-        @adapter.storage_exists?("sputniks").should be_true
-        @adapter.field_exists?("sputniks", "new_prop").should be_false
-        Sputnik.property :new_prop, DM::Serial
-        @adapter.send(:drop_sequence, repository(:postgres), Sputnik.new_prop)
-        Sputnik.auto_upgrade!(:postgres)
-        @adapter.field_exists?("sputniks", "new_prop").should == true
-      end
-    end
-
-    describe '#312' do
-      it "should behave sanely for time fields" do
-
-        class ::Thing
-          include DataMapper::Resource
-          property :id, Integer, :serial => true
-          property :created_at, Time
-        end
-
-        Thing.auto_migrate!(:postgres)
-
-        repository(:postgres) do
-          time_now = Time.now
-
-          t = Thing.new
-          t.created_at = time_now
-
-          t.save
-
-          t1 = Thing.first
-          t1.created_at.should == time_now
-        end
-
-      end
-    end
-
-    describe "querying metadata" do
-      before :all do
-        class ::Sputnik
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, DM::Text
-        end
-
-        Sputnik.auto_migrate!(:postgres)
-      end
-
-      it "#storage_exists? should return true for tables that exist" do
-        @adapter.storage_exists?("sputniks").should == true
-      end
-
-      it "#storage_exists? should return false for tables that don't exist" do
-        @adapter.storage_exists?("space turds").should == false
-      end
-
-      it "#field_exists? should return true for columns that exist" do
-        @adapter.field_exists?("sputniks", "name").should == true
-      end
-
-      it "#field_exists? should return false for columns that don't exist" do
-        @adapter.field_exists?("sputniks", "plur").should == false
-      end
-    end
-
-    describe "handling transactions" do
-      before :all do
-        class ::Sputnik
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, DM::Text
-        end
-
-        Sputnik.auto_migrate!(:postgres)
-      end
-
-      before do
-        @transaction = DataMapper::Transaction.new(@adapter)
-      end
-
-      it "should rollback changes when #rollback_transaction is called" do
-        @transaction.commit do |trans|
-          @adapter.execute("INSERT INTO sputniks (name) VALUES ('my pretty sputnik')")
-          trans.rollback
-        end
-        @adapter.query("SELECT * FROM sputniks WHERE name = 'my pretty sputnik'").empty?.should == true
-      end
-
-      it "should commit changes when #commit_transaction is called" do
-        @transaction.commit do
-          @adapter.execute("INSERT INTO sputniks (name) VALUES ('my pretty sputnik')")
-        end
-        @adapter.query("SELECT * FROM sputniks WHERE name = 'my pretty sputnik'").size.should == 1
-      end
-    end
-
-    describe "reading & writing a database" do
-      before :all do
-        class ::User
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, DM::Text
-        end
-
-        class ::Voyager
-          include DataMapper::Resource
-          storage_names[:postgres] = 'voyagers'
-
-          property :id, Serial
-          property :age, Integer
-        end
-
-        # Voyager.auto_migrate!(:postgres)
-      end
-
-      before do
-        User.auto_migrate!(:postgres)
-
-        @adapter.execute("INSERT INTO users (name) VALUES ('Paul')")
-      end
-
-      it "should be able to specify a schema name as part of the storage name" do
-        pending "This works, but no create-schema support in PostgresAdapter to easily test with"
-        lambda do
-          repository(:postgres) do
-            Voyager.create(:age => 1_000)
-          end
-        end.should_not raise_error
-      end
-
-      it 'should be able to #execute an arbitrary query' do
-        result = @adapter.execute("INSERT INTO users (name) VALUES ('Sam')")
-
-        result.affected_rows.should == 1
-      end
-
-      it 'should be able to #query' do
-        result = @adapter.query("SELECT * FROM users")
-
-        result.should be_kind_of(Array)
-        row = result.first
-        row.should be_kind_of(Struct)
-        row.members.map { |m| m.to_s }.should == %w{id name}
-
-        row.id.should == 1
-        row.name.should == 'Paul'
-      end
-
-      it 'should return an empty array if #query found no rows' do
-        @adapter.execute("DELETE FROM users")
-
-        result = nil
-        lambda { result = @adapter.query("SELECT * FROM users") }.should_not raise_error
-
-        result.should be_kind_of(Array)
-        result.size.should == 0
-      end
-    end
-
-    describe "CRUD for serial Key" do
-      before :all do
-        class ::VideoGame
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :name, String
-          property :object, Object
-        end
-      end
-
-      before do
-        VideoGame.auto_migrate!(:postgres)
-      end
-
-      it 'should be able to create a record' do
-        time = Time.now
-        game = VideoGame.new(:name => 'System Shock', :object => time)
-        repository(:postgres) do
-          game.save
-          game.should_not be_a_new_record
-          game.should_not be_dirty
-
-          saved = VideoGame.first(:name => game.name)
-          saved.id.should == game.id
-          saved.object.should == time
-        end
-      end
-
-      it 'should be able to read a record' do
-        name = 'Wing Commander: Privateer'
-        id = @adapter.execute('INSERT INTO "video_games" ("name") VALUES (?) RETURNING id', name).insert_id
-
-        game = repository(:postgres) do
-          VideoGame.get(id)
-        end
-
-        game.name.should == name
-        game.should_not be_dirty
-        game.should_not be_a_new_record
-      end
-
-      it 'should be able to update a record' do
-        name = 'Resistance: Fall of Mon'
-        id = @adapter.execute('INSERT INTO "video_games" ("name") VALUES (?) RETURNING id', name).insert_id
-
-        game = repository(:postgres) do
-          VideoGame.get(id)
-        end
-
-        game.should_not be_a_new_record
-
-        game.should_not be_dirty
-        game.name = game.name.sub(/Mon/, 'Man')
-        game.should be_dirty
-
-        repository(:postgres) do
-          game.save
-        end
-
-        game.should_not be_dirty
-
-        clone = repository(:postgres) do
-          VideoGame.get(id)
-        end
-
-        clone.name.should == game.name
-      end
-
-      it 'should be able to delete a record' do
-        name = 'Zelda'
-        id = @adapter.execute('INSERT INTO "video_games" ("name") VALUES (?) RETURNING id', name).insert_id
-
-        game = repository(:postgres) do
-          VideoGame.get(id)
-        end
-
-        game.name.should == name
-
-        repository(:postgres) do
-          game.destroy.should be_true
-        end
-
-        game.should be_a_new_record
-        game.should be_dirty
-      end
-
-      it 'should respond to Resource#get' do
-        name = 'Contra'
-        id = @adapter.execute('INSERT INTO "video_games" ("name") VALUES (?) RETURNING id', name).insert_id
-
-        contra = repository(:postgres) { VideoGame.get(id) }
-
-        contra.should_not be_nil
-        contra.should_not be_dirty
-        contra.should_not be_a_new_record
-        contra.id.should == id
-      end
-    end
-
-    describe "CRUD for Composite Key" do
-      before :all do
-        class ::BankCustomer
-          include DataMapper::Resource
-
-          property :bank, String, :key => true
-          property :account_number, String, :key => true
-          property :name, String
-        end
-      end
-
-      before do
-        BankCustomer.auto_migrate!(:postgres)
-      end
-
-      it 'should be able to create a record' do
-        customer = BankCustomer.new(:bank => 'Community Bank', :account_number => '123456', :name => 'David Hasselhoff')
-        repository(:postgres) do
-          customer.save
-        end
-
-        customer.should_not be_a_new_record
-        customer.should_not be_dirty
-
-        row = @adapter.query('SELECT "bank", "account_number" FROM "bank_customers" WHERE "name" = ?', customer.name).first
-        row.bank.should == customer.bank
-        row.account_number.should == customer.account_number
-      end
-
-      it 'should be able to read a record' do
-        bank, account_number, name = 'Chase', '4321', 'Super Wonderful'
-        @adapter.execute('INSERT INTO "bank_customers" ("bank", "account_number", "name") VALUES (?, ?, ?)', bank, account_number, name)
-
-        repository(:postgres) do
-          BankCustomer.get(bank, account_number).name.should == name
-        end
-      end
-
-      it 'should be able to update a record' do
-        bank, account_number, name = 'Wells Fargo', '00101001', 'Spider Pig'
-        @adapter.execute('INSERT INTO "bank_customers" ("bank", "account_number", "name") VALUES (?, ?, ?)', bank, account_number, name)
-
-        customer = repository(:postgres) do
-          BankCustomer.get(bank, account_number)
-        end
-
-        customer.name = 'Bat-Pig'
-
-        customer.should_not be_a_new_record
-        customer.should be_dirty
-
-        customer.save
-
-        customer.should_not be_dirty
-
-        clone = repository(:postgres) do
-          BankCustomer.get(bank, account_number)
-        end
-
-        clone.name.should == customer.name
-      end
-
-      it 'should be able to delete a record' do
-        bank, account_number, name = 'Megacorp', 'ABC', 'Flash Gordon'
-        @adapter.execute('INSERT INTO "bank_customers" ("bank", "account_number", "name") VALUES (?, ?, ?)', bank, account_number, name)
-
-        customer = repository(:postgres) do
-          BankCustomer.get(bank, account_number)
-        end
-
-        customer.name.should == name
-
-        repository(:postgres) do
-          customer.destroy.should be_true
-        end
-
-        customer.should be_a_new_record
-        customer.should be_dirty
-      end
-
-      it 'should respond to Resource#get' do
-        bank, account_number, name = 'Conchords', '1100101', 'Robo Boogie'
-        @adapter.execute('INSERT INTO "bank_customers" ("bank", "account_number", "name") VALUES (?, ?, ?)', bank, account_number, name)
-
-        robots = repository(:postgres) { BankCustomer.get(bank, account_number) }
-
-        robots.should_not be_nil
-        robots.should_not be_dirty
-        robots.should_not be_a_new_record
-        robots.bank.should == bank
-        robots.account_number.should == account_number
-      end
-    end
-
-    describe "Ordering a Query" do
-      before :all do
-        class ::SailBoat
-          include DataMapper::Resource
-          property :id, Serial
-          property :name, String
-          property :port, String
-        end
-      end
-
-      before do
-        SailBoat.auto_migrate!(:postgres)
-
-        repository(:postgres) do
-          SailBoat.create(:id => 1, :name => "A", :port => "C")
-          SailBoat.create(:id => 2, :name => "B", :port => "B")
-          SailBoat.create(:id => 3, :name => "C", :port => "A")
-        end
-      end
-
-      it "should order results" do
-        repository(:postgres) do
-          result = SailBoat.all(:order => [
-              DataMapper::Query::Direction.new(SailBoat.properties[:name], :asc)
-          ])
-          result[0].id.should == 1
-
-          result = SailBoat.all(:order => [
-              DataMapper::Query::Direction.new(SailBoat.properties[:port], :asc)
-          ])
-          result[0].id.should == 3
-
-          result = SailBoat.all(:order => [
-              DataMapper::Query::Direction.new(SailBoat.properties[:name], :asc),
-              DataMapper::Query::Direction.new(SailBoat.properties[:port], :asc)
-          ])
-          result[0].id.should == 1
-
-          result = SailBoat.all(:order => [
-              SailBoat.properties[:name],
-              DataMapper::Query::Direction.new(SailBoat.properties[:port], :asc)
-          ])
-          result[0].id.should == 1
-        end
-      end
-    end
-
-    describe "Lazy Loaded Properties" do
-      before :all do
-        class ::SailBoat
-          include DataMapper::Resource
-          property :id, Serial
-          property :notes, String, :lazy => [:notes]
-          property :trip_report, String, :lazy => [:notes,:trip]
-          property :miles, Integer, :lazy => [:trip]
-        end
-      end
-
-      before do
-        SailBoat.auto_migrate!(:postgres)
-
-        repository(:postgres) do
-          SailBoat.create(:id => 1, :notes=>'Note',:trip_report=>'Report',:miles=>23)
-          SailBoat.create(:id => 2, :notes=>'Note',:trip_report=>'Report',:miles=>23)
-          SailBoat.create(:id => 3, :notes=>'Note',:trip_report=>'Report',:miles=>23)
-        end
-      end
-
-      it "should lazy load" do
-        result = repository(:postgres) { SailBoat.all.to_a }
-
-        result[0].attribute_loaded?(:notes).should be_false
-        result[0].attribute_loaded?(:trip_report).should be_false
-        result[1].attribute_loaded?(:notes).should be_false
-
-        result[1].notes.should_not be_nil
-
-        result[1].attribute_loaded?(:notes).should be_true
-        result[1].attribute_loaded?(:trip_report).should be_true
-        result[1].attribute_loaded?(:miles).should be_false
-
-        result = repository(:postgres) { SailBoat.all.to_a }
-
-        result[0].attribute_loaded?(:trip_report).should be_false
-        result[0].attribute_loaded?(:miles).should be_false
-
-        result[1].trip_report.should_not be_nil
-        result[2].attribute_loaded?(:miles).should be_true
-      end
-    end
-
-    describe "finders" do
-      before :all do
-        class ::SerialFinderSpec
-          include DataMapper::Resource
-
-          property :id, Serial
-          property :sample, String
-        end
-      end
-
-      before do
-        SerialFinderSpec.auto_migrate!(:postgres)
-
-        repository(:postgres) do
-          100.times do
-            SerialFinderSpec.create(:sample => rand.to_s)
-          end
-        end
-      end
-
-      it "should return all available rows" do
-        repository(:postgres) do
-          SerialFinderSpec.all.should have(100).entries
-        end
-      end
-
-      it "should allow limit and offset" do
-        repository(:postgres) do
-          SerialFinderSpec.all(:limit => 50).should have(50).entries
-
-          SerialFinderSpec.all(:limit => 20, :offset => 40).map { |entry| entry.id }.should == SerialFinderSpec.all[40...60].map { |entry| entry.id }
-        end
-      end
-
-      it "should lazy-load missing attributes" do
-        sfs = repository(:postgres) do
-          SerialFinderSpec.first(:fields => [ :id ])
-        end
-
-        sfs.should be_a_kind_of(SerialFinderSpec)
-        sfs.should_not be_a_new_record
-
-        sfs.attribute_loaded?(:sample).should be_false
-        sfs.sample
-        sfs.attribute_loaded?(:sample).should be_true
-      end
-
-      it "should translate an Array to an IN clause" do
-        ids = repository(:postgres) do
-          SerialFinderSpec.all(:limit => 10).map { |entry| entry.id }
-        end
-
-        results = repository(:postgres) do
-          SerialFinderSpec.all(:id => ids)
-        end
-
-        results.size.should == 10
-        results.map { |entry| entry.id }.should == ids
-      end
-    end
-
-    describe "belongs_to associations" do
-      before :all do
-        class ::Engine
-          include DataMapper::Resource
-          def self.default_repository_name; :postgres end
-
-          property :id, Serial
-          property :name, String
-        end
-
-        class ::Yard
-          include DataMapper::Resource
-          def self.default_repository_name; :postgres end
-
-          property :id, Serial
-          property :name, String
-          property :engine_id, Integer
-
-          belongs_to :engine
-        end
-      end
-
-      before do
-        Engine.auto_migrate!(:postgres)
-
-        @adapter.execute('INSERT INTO "engines" ("id", "name") values (?, ?)', 1, 'engine1')
-        @adapter.execute('INSERT INTO "engines" ("id", "name") values (?, ?)', 2, 'engine2')
-
-        Yard.auto_migrate!(:postgres)
-
-        @adapter.execute('INSERT INTO "yards" ("id", "name", "engine_id") values (?, ?, ?)', 1, 'yard1', 1)
-      end
-
-      it "should load without the parent"
-
-      it 'should allow substituting the parent' do
-        repository(:postgres) do
-          y = Yard.first(:id => 1)
-          e = Engine.first(:id => 2)
-          y.engine = e
-          y.save
-        end
-
-        repository(:postgres) do
-          Yard.first(:id => 1).engine_id.should == 2
-        end
-      end
-
-      it "#belongs_to" do
-        yard = Yard.new
-        yard.should respond_to(:engine)
-        yard.should respond_to(:engine=)
-      end
-
-      it "should load the associated instance" do
-        y = repository(:postgres) do
-          Yard.first(:id => 1)
-        end
-        y.engine.should_not be_nil
-        y.engine.id.should == 1
-        y.engine.name.should == "engine1"
-      end
-
-      it 'should save the association key in the child' do
-        repository(:postgres) do
-          e = Engine.first(:id => 2)
-          Yard.create(:id => 2, :name => 'yard2', :engine => e)
-        end
-
-        repository(:postgres) do
-          Yard.first(:id => 2).engine_id.should == 2
-        end
-      end
-
-      it 'should save the parent upon saving of child' do
-        repository(:postgres) do
-          e = Engine.new(:id => 10, :name => "engine10")
-          y = Yard.new(:id => 10, :name => "Yard10", :engine => e)
-          y.save
-
-          y.engine_id.should == 10
-        end
-
-        repository(:postgres) do
-          Engine.first(:id => 10).should_not be_nil
-        end
-      end
-    end
-
-    describe "has n associations" do
-      before :all do
-        class ::Host
-          include DataMapper::Resource
-          def self.default_repository_name; :postgres end
-
-          property :id, Serial
-          property :name, String
-
-          has n, :slices
-        end
-
-        class ::Slice
-          include DataMapper::Resource
-          def self.default_repository_name; :postgres end
-
-          property :id, Serial
-          property :name, String
-          property :host_id, Integer
-
-          belongs_to :host
-        end
-      end
-
-      before do
-        Host.auto_migrate!(:postgres)
-        Slice.auto_migrate!(:postgres)
-
-        @adapter.execute('INSERT INTO "hosts" ("id", "name") values (?, ?)', 1, 'host1')
-        @adapter.execute('INSERT INTO "hosts" ("id", "name") values (?, ?)', 2, 'host2')
-
-        @adapter.execute('INSERT INTO "slices" ("id", "name", "host_id") values (?, ?, ?)', 1, 'slice1', 1)
-        @adapter.execute('INSERT INTO "slices" ("id", "name", "host_id") values (?, ?, ?)', 2, 'slice2', 1)
-      end
-
-      it "#has n" do
-        h = Host.new
-        h.should respond_to(:slices)
-      end
-
-      it "should allow removal of a child through a loaded association" do
-        h = repository(:postgres) do
-          Host.first(:id => 1)
-        end
-
-        s = h.slices.first
-
-        h.slices.delete(s)
-        h.slices.size.should == 1
-        h.save
-
-        s = repository(:postgres) do
-          Slice.first(:id => s.id)
-        end
-
-        s.host.should be_nil
-        s.host_id.should be_nil
-      end
-
-      it "should load the associated instances" do
-        h = repository(:postgres) do
-          Host.first(:id => 1)
-        end
-
-        h.slices.should_not be_nil
-        h.slices.size.should == 2
-        h.slices.first.id.should == 1
-        h.slices.last.id.should == 2
-      end
-
-      it "should add and save the associated instance" do
-        repository(:postgres) do
-          h = Host.first(:id => 1)
-
-          h.slices << Slice.new(:id => 3, :name => 'slice3')
-          h.save
-
-          s = repository(:postgres) do
-            Slice.first(:id => 3)
-          end
-
-          s.host.id.should == 1
-        end
-      end
-
-      it "should not save the associated instance if the parent is not saved" do
-        repository(:postgres) do
-          h = Host.new(:id => 10, :name => "host10")
-          h.slices << Slice.new(:id => 10, :name => 'slice10')
-        end
-
-        repository(:postgres) do
-          Slice.first(:id => 10).should be_nil
-        end
-      end
-
-      it "should save the associated instance upon saving of parent" do
-        repository(:postgres) do
-          h = Host.new(:id => 10, :name => "host10")
-          h.slices << Slice.new(:id => 10, :name => 'slice10')
-          h.save
-        end
-
-        s = repository(:postgres) do
-          Slice.first(:id => 10)
-        end
-
-        s.should_not be_nil
-        s.host.should_not be_nil
-        s.host.id.should == 10
-      end
-    end
-  end
-end