datamapper 0.2.5 → 0.3.0

data/spec/conditions_spec.rb

@@ -1,49 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe DataMapper::Adapters::Sql::Commands::LoadCommand do
-  
-  def conditions_for(klass, options = {})
-    database_context = database(:mock)
-    DataMapper::Adapters::Sql::Commands::LoadCommand.new(
-      database_context.adapter, database_context, klass, options
-    ).conditions
-  end
-  
-  it 'empty? should be false if conditions are present' do
-    conditions_for(Zoo, :name => 'Galveston').should_not be_empty
-  end
-  
-  it 'should map implicit option names to field names' do
-    conditions_for(Zoo, :name => 'Galveston').should eql([["`name` = ?", 'Galveston']])
-  end
-  
-  it 'should qualify with table name when using a join' do
-    conditions_for(Zoo, :name => 'Galveston', :include => :exhibits).should eql([["`zoos`.`name` = ?", 'Galveston']])
-  end
-  
-  it 'should use Symbol::Operator to determine operator' do
-    conditions_for(Person, :age.gt => 28).should eql([["`age` > ?", 28]])
-    conditions_for(Person, :age.gte => 28).should eql([["`age` >= ?", 28]])
-    
-    conditions_for(Person, :age.lt => 28).should eql([["`age` < ?", 28]])
-    conditions_for(Person, :age.lte => 28).should eql([["`age` <= ?", 28]])
-    
-    conditions_for(Person, :age.not => 28).should eql([["`age` <> ?", 28]])
-    conditions_for(Person, :age.eql => 28).should eql([["`age` = ?", 28]])
-    
-    conditions_for(Person, :name.like => 'S%').should eql([["`name` LIKE ?", 'S%']])
-    
-    conditions_for(Person, :age.in => [ 28, 29 ]).should eql([["`age` IN ?", [ 28, 29 ]]])
-  end
-  
-  it 'should use an IN clause for an Array' do
-    conditions_for(Person, :age => [ 28, 29 ]).should eql([["`age` IN ?", [ 28, 29 ]]])
-  end
-  
-  it 'should use "not" for not-equal operations' do
-    conditions_for(Person, :name.not => 'Bob').should eql([["`name` <> ?", 'Bob']])
-    conditions_for(Person, :name.not => nil).should eql([["`name` IS NOT ?", nil]])
-    conditions_for(Person, :name.not => ['Sam', 'Bob']).should eql([["`name` NOT IN ?", ['Sam', 'Bob']]])
-  end
-
-end

data/spec/has_many_association_spec.rb

@@ -1,173 +0,0 @@
-require File.dirname(__FILE__) + "/spec_helper"
-
-describe DataMapper::Associations::HasManyAssociation do
-  
-  before(:all) do
-    fixtures(:zoos)
-    fixtures(:exhibits)
-    fixtures(:fruit)
-    fixtures(:animals)
-  end
-
-  after(:all) do
-    fixtures(:fruit)
-    fixtures(:animals)
-  end
-
-  before(:each) do
-    @zoo = Zoo.new(:name => "ZOO")
-    @zoo.save 
-  end
-  
-  after(:each) do
-    @zoo.destroy!
-  end
-  
-  it "should return an empty Enumerable for new objects" do
-    project = Project.new
-    project.sections.should be_a_kind_of(Enumerable)
-    project.sections.should be_empty
-  end
-  
-  it "should display correctly when inspected" do
-    Zoo.first(:name => 'Dallas').exhibits.inspect.should match(/\#\<Exhibit\:0x.{7}/)
-  end
-  
-  it 'should lazily-load the association when Enumerable methods are called' do
-    database do |db|
-      san_diego = Zoo.first(:name => 'San Diego')
-      san_diego.exhibits.size.should == 2
-      san_diego.exhibits.should include(Exhibit.first(:name => 'Monkey Mayhem'))
-    end
-  end
-  
-  it 'should eager-load associations for an entire set' do
-    database do
-      zoos = Zoo.all
-      zoos.each do |zoo|
-        zoo.exhibits.each do |exhibit|
-          exhibit.zoo.should == zoo
-        end
-      end
-    end
-  end
-  
-  it "should be dirty even when clean objects are associated" do
-    zoo = Zoo.first(:name => 'New York')
-    zoo.exhibits << Exhibit.first
-    zoo.should be_dirty
-  end
-  
-  it "should proxy associations on the associated type" do
-    Zoo.first(:name => 'Miami').exhibits.animals.size.should == 1
-  end
-  
-  it "should have a valid zoo setup for testing" do
-    @zoo.should be_valid
-    @zoo.should_not be_a_new_record
-    @zoo.id.should_not be_nil
-  end  
-  
-  it "should generate the SQL for a join statement" do
-    exhibits_association = database(:mock).schema[Zoo].associations.find { |a| a.name == :exhibits }
-  
-    exhibits_association.to_sql.should == <<-EOS.compress_lines
-      JOIN `exhibits` ON `exhibits`.`zoo_id` = `zoos`.`id`
-    EOS
-  end
-
-  it "should add an item to an association" do
-    bear = Exhibit.new( :name => "Bear")
-    @zoo.exhibits << bear
-    @zoo.exhibits.should include(bear)
-  end
-  
-  it "should build a new item" do
-    bear = @zoo.exhibits.build( :name => "Bear" )
-    bear.should be_kind_of(Exhibit)
-    @zoo.exhibits.should include(bear)
-  end
-
-  it "should not save the item when building" do
-    bear = @zoo.exhibits.build( :name => "Bear" )
-    bear.should be_new_record
-  end
-  
-  it "should create a new item" do
-    bear = @zoo.exhibits.create( :name => "Bear" )
-    bear.should be_kind_of(Exhibit)
-    @zoo.exhibits.should include(bear)
-  end
-
-  it "should save the item when creating" do
-    bear = @zoo.exhibits.create( :name => "Bear" )
-    bear.should_not be_new_record
-  end
-
-  it "should set the association to a saved target when added with <<" do    
-    pirahna = Exhibit.new(:name => "Pirahna")
-    pirahna.zoo_id.should be_nil
-    
-    @zoo.exhibits << pirahna
-    pirahna.zoo.should == @zoo
-  end
-  
-  it "should set the association to a non-saved target when added with <<" do
-    zoo = Zoo.new(:name => "My Zoo")
-    kangaroo = Exhibit.new(:name => "Kangaroo")
-    zoo.exhibits << kangaroo
-    kangaroo.zoo.should == zoo
-  end
-  
-  it "should set the id of the exhibit when the associated zoo is saved" do
-    snake = Exhibit.new(:name => "Snake")
-    @zoo.exhibits << snake
-    @zoo.save
-    @zoo.id.should == snake.zoo_id
-  end
-  
-  it "should set the id of an already saved exibit if it's added to a different zoo" do
-    beaver = Exhibit.new(:name => "Beaver")
-    beaver.save
-    beaver.should_not be_a_new_record
-    @zoo.exhibits << beaver
-    @zoo.save
-    beaver.zoo.should == @zoo
-    beaver.zoo_id.should == @zoo.id    
-  end
-  
-  it "should set the size of the assocation" do
-    @zoo.exhibits << Exhibit.new(:name => "anonymous")
-    @zoo.exhibits.size.should == 1
-  end
-  
-  it "should give the association when an inspect is done on it" do
-    whale = Exhibit.new(:name => "Whale")
-    @zoo.exhibits << whale
-    @zoo.exhibits.should_not == "nil"
-    @zoo.exhibits.inspect.should_not be_nil
-  end
-  
-  it "should generate the SQL for a join statement" do
-    fruit_association = database(:mock).schema[Animal].associations.find { |a| a.name == :favourite_fruit }
-  
-    fruit_association.to_sql.should == <<-EOS.compress_lines
-      JOIN `fruit` ON `fruit`.`devourer_id` = `animals`.`id`
-    EOS
-  end
-
-  it "is assigned a devourer_id" do
-    bob = Animal.new(:name => 'bob')
-    fruit = Fruit.first
-    bob.favourite_fruit = fruit
-    
-    bob.save
-    
-    bob.reload!
-    fruit.devourer_id.should eql(bob.id)
-    bob.favourite_fruit.should == fruit
-    
-    fruit.reload!
-    fruit.devourer_of_souls.should == bob
-  end
-end

data/spec/models/animals_exhibit.rb

@@ -1,8 +0,0 @@
-# This is just here to get around the fact I use a Class to load
-# fixtures right now.
-class AnimalsExhibit #< DataMapper::Base
-  include DataMapper::Persistence
-
-  property :animal_id, :integer, :key => true
-  property :exhibit_id, :integer, :key => true
-end