sam-dm-core 0.9.6

data/spec/integration/data_objects_adapter_spec.rb

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

@@ -0,0 +1,58 @@
+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 "#initialize" do
+    describe "@dependencies" do
+      it "should be a hash after initialize" do
+        @dependencies.should be_a_kind_of(Hash)
+      end
+
+      it "should set value to [] when new key is accessed" do
+        @dependencies['New Key'].should == []
+      end
+    end
+  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

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

data/spec/integration/mysql_adapter_spec.rb

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

@@ -0,0 +1,731 @@
+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] = 'sattellites.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.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