dm-core 0.9.2

data/spec/integration/association_through_spec.rb

@@ -0,0 +1,150 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+if ADAPTER
+  describe 'through-associations' do
+    before :all do
+      repository(ADAPTER) do
+
+        class Tag
+          include DataMapper::Resource
+          def self.default_repository_name
+            ADAPTER
+          end
+
+          property :id,     Serial
+          property :title,  String
+          property :voided, Boolean, :default => false
+
+          has n, :taggings
+
+          has n, :relationships
+          has n, :related_posts, :through => :relationships, :class_name => 'Post'
+
+          has n, :posts, :through => :taggings
+        end
+
+        class Tagging
+          include DataMapper::Resource
+          def self.default_repository_name
+            ADAPTER
+          end
+
+          property :id, Serial
+          property :title, String
+
+          belongs_to :post
+          belongs_to :tag
+        end
+
+        class Post
+          include DataMapper::Resource
+          def self.default_repository_name
+            ADAPTER
+          end
+
+          property :id, Serial
+          property :title, String
+
+          has n, :taggings
+          has n, :tags, :through => :taggings
+
+          has n, :relationships
+          has n, :related_posts,
+                 :through    => :relationships,
+                 :class_name => "Post"
+
+          has n,  :void_tags,
+                  :through => :taggings,
+                  :class_name => "Tag",
+                  :remote_relationship_name => :tag,
+                  Post.taggings.tag.voided => true
+        end
+
+        class Relationship
+          include DataMapper::Resource
+          def self.default_repository_name
+            ADAPTER
+          end
+
+          property :id, Serial
+          belongs_to :post
+          belongs_to :related_post, :class_name => "Post"
+        end
+
+        [Post, Tag, Tagging, Relationship].each do |descendant|
+          descendant.auto_migrate!(ADAPTER)
+        end
+
+        post = Post.create(:title => "Entry")
+        another_post = Post.create(:title => "Another")
+
+        crappy = Tagging.new
+        post.taggings << crappy
+        post.save
+
+        crap = Tag.create(:title => "crap")
+        crap.taggings << crappy
+        crap.save
+
+        crappier = Tagging.new
+        post.taggings << crappier
+        post.save
+
+        crapz = Tag.create(:title => "crapz", :voided => true)
+        crapz.taggings << crappier
+        crapz.save
+
+        goody = Tagging.new
+        another_post.taggings << goody
+        another_post.save
+
+        good = Tag.create(:title => "good")
+        good.taggings << goody
+        good.save
+
+        relation = Relationship.new(:related_post => another_post)
+        post.relationships << relation
+        post.save
+      end
+    end
+
+    it 'should return the right children for has n => belongs_to relationships' do
+      Post.first.tags.select do |tag|
+        tag.title == 'crap'
+      end.size.should == 1
+    end
+
+    it 'should return the right children for has n => belongs_to self-referential relationships' do
+      Post.first.related_posts.select do |post|
+        post.title == 'Another'
+      end.size.should == 1
+    end
+
+    it 'should handle all()' do
+      related_posts = Post.first.related_posts
+      related_posts.all.object_id.should == related_posts.object_id
+      related_posts.all(:id => 2).first.should == Post.get!(2)
+    end
+
+    it 'should handle first()' do
+      post = Post.get!(2)
+      related_posts = Post.first.related_posts
+      related_posts.first.should == post
+      related_posts.first(10).should == [ post ]
+      related_posts.first(:id => 2).should == post
+      related_posts.first(10, :id => 2).map { |r| r.id }.should == [ post.id ]
+    end
+
+    it 'should proxy object should be frozen' do
+      Post.first.related_posts.should be_frozen
+    end
+
+    it "should respect tagging with conditions" do
+      post = Post.get(1)
+      post.tags.size
+      post.tags.select{|t| t.voided == true}.size.should == 1
+      post.void_tags.size.should == 1
+      post.void_tags.all?{|t| t.voided == true}.should be_true
+    end
+  end
+end

data/spec/integration/associations/many_to_many_spec.rb

@@ -0,0 +1,171 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe DataMapper::Associations::ManyToMany::Proxy do
+  before :all do
+    class Editor
+      include DataMapper::Resource
+
+      def self.default_repository_name; ADAPTER end
+
+      property :id, Serial
+      property :name, String
+
+      has n, :books, :through => Resource
+    end
+
+    class Book
+      include DataMapper::Resource
+
+      def self.default_repository_name; ADAPTER end
+
+      property :id, Serial
+      property :title, String
+
+      has n, :editors, :through => Resource
+    end
+
+    [ Book, Editor, BookEditor ].each { |k| k.auto_migrate! }
+
+    repository(ADAPTER) do
+      book_1 = Book.create(:title => "Dubliners")
+      book_2 = Book.create(:title => "Portrait of the Artist as a Young Man")
+      book_3 = Book.create(:title => "Ulysses")
+
+      editor_1 = Editor.create(:name => "Jon Doe")
+      editor_2 = Editor.create(:name => "Jane Doe")
+
+      BookEditor.create(:book => book_1, :editor => editor_1)
+      BookEditor.create(:book => book_2, :editor => editor_1)
+      BookEditor.create(:book => book_1, :editor => editor_2)
+    end
+  end
+
+  it "should correctly link records" do
+    Editor.get(1).books.size.should == 2
+    Editor.get(2).books.size.should == 1
+    Book.get(1).editors.size.should == 2
+    Book.get(2).editors.size.should == 1
+  end
+
+  it "should be able to have associated objects manually added" do
+    book = Book.get(3)
+    # book.editors.size.should == 0
+
+    be = BookEditor.new(:book_id => book.id, :editor_id => 2)
+    book.book_editors << be
+    book.save
+
+    book.reload
+    book.editors.size.should == 1
+  end
+
+  it "should automatically added necessary through class" do
+    book = Book.get(3)
+    book.editors << Editor.get(1)
+    book.editors << Editor.new(:name => "Jimmy John")
+    book.save
+    book.editors.size.should == 3
+  end
+
+  it "should react correctly to a new record" do
+    book = Book.new(:title => "Finnegan's Wake")
+    book.editors << Editor.get(2)
+    book.save
+    book.editors.size.should == 1
+    Editor.get(2).books.size.should == 3
+  end
+
+  it "should be able to delete intermediate model" do
+    book = Book.get(3)
+    be = BookEditor.get(3,1)
+    book.book_editors.delete(be)
+    book.save
+    book.reload
+    book = Book.get(3)
+    book.book_editors.size.should == 2
+    book.editors.size.should == 2
+  end
+
+  it "should be clearable" do
+    repository(ADAPTER) do
+      book = Book.get(2)
+      book.editors.size.should == 1
+      book.editors.clear
+      book.save
+      book.reload
+      book.book_editors.size.should == 0
+      book.editors.size.should == 0
+    end
+    repository(ADAPTER) do
+      Book.get(2).editors.size.should == 0
+    end
+  end
+
+  it "should be able to delete one object" do
+    book = Book.get(1)
+    editor = book.editors.first
+
+    book.editors.size.should == 2
+    book.editors.delete(editor)
+    book.book_editors.size.should == 1
+    book.editors.size.should == 1
+    book.save
+    book.reload
+    Editor.get(1).books.should_not include(book)
+  end
+
+  it "should be destroyable" do
+    pending 'cannot destroy a collection yet' do
+      book = Book.get(3)
+      book.editors.destroy
+      book.save
+      book.reload
+      book.editors.size.should == 0
+    end
+  end
+
+  describe 'with natural keys' do
+    before :all do
+      class Author
+        include DataMapper::Resource
+
+        def self.default_repository_name; ADAPTER end
+
+        property :name, String, :key => true
+
+        has n, :books, :through => Resource
+      end
+
+      class Book
+        has n, :authors, :through => Resource
+      end
+
+      [ Author, AuthorBook ].each { |k| k.auto_migrate! }
+
+      @author = Author.create(:name =>  'James Joyce')
+
+      @book_1 = Book.get!(1)
+      @book_2 = Book.get!(2)
+      @book_3 = Book.get!(3)
+
+      AuthorBook.create(:book => @book_1, :author => @author)
+      AuthorBook.create(:book => @book_2, :author => @author)
+      AuthorBook.create(:book => @book_3, :author => @author)
+    end
+
+    it 'should have a join resource where the natural key is a property' do
+      AuthorBook.properties[:author_name].primitive.should == String
+    end
+
+    it 'should have a join resource where every property is part of the key' do
+      AuthorBook.key.should == AuthorBook.properties.to_a
+    end
+
+    it 'should correctly link records' do
+      @author.books.should have(3).entries
+      @book_1.authors.should have(1).entries
+      @book_2.authors.should have(1).entries
+      @book_3.authors.should have(1).entries
+    end
+  end
+end

data/spec/integration/associations/many_to_one_spec.rb

@@ -0,0 +1,123 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+if ADAPTER
+  module ManyToOneSpec
+    class Parent
+      include DataMapper::Resource
+
+      def self.default_repository_name
+        ADAPTER
+      end
+
+      property :id,   Serial
+      property :name, String
+    end
+
+    class Child
+      include DataMapper::Resource
+
+      def self.default_repository_name
+        ADAPTER
+      end
+
+      property :id,   Serial
+      property :name, String
+
+      belongs_to :parent, :class_name => 'ManyToOneSpec::Parent'
+    end
+  end
+
+  describe DataMapper::Associations::ManyToOne::Proxy do
+    before do
+      ManyToOneSpec::Parent.auto_migrate!
+      ManyToOneSpec::Child.auto_migrate!
+
+      @parent      = ManyToOneSpec::Parent.create(:name => 'parent')
+      @child       = ManyToOneSpec::Child.create(:name => 'child', :parent => @parent)
+      @other       = ManyToOneSpec::Parent.create(:name => 'other parent')
+      @association = @child.parent
+    end
+
+    describe '#replace' do
+      it 'should remove the resource from the collection' do
+        @association.should == @parent
+        @association.replace(@other)
+        @association.should == @other
+      end
+
+      it 'should not automatically save that the resource was removed from the association' do
+        @association.replace(@other)
+        @child.reload.parent.should == @parent
+      end
+
+      it 'should return the association' do
+        @association.replace(@other).object_id.should == @association.object_id
+      end
+    end
+
+    describe '#save' do
+      describe 'when the parent is nil' do
+        before do
+          @association.replace(nil)
+        end
+
+        it 'should not save the parent' do
+          @association.save
+        end
+
+        it 'should return false' do
+          @association.save.should == false
+        end
+      end
+
+      describe 'when the parent is not a new record' do
+        before do
+          @parent.should_not be_new_record
+        end
+
+        it 'should not save the parent' do
+          @parent.should_not_receive(:save)
+          @association.save
+        end
+
+        it 'should return true' do
+          @association.save.should == true
+        end
+      end
+
+      describe 'when the parent is a new record' do
+        before do
+          @parent = ManyToOneSpec::Parent.new(:name => 'unsaved parent')
+          @parent.should be_new_record
+          @association.replace(@parent)
+        end
+
+        it 'should save the parent' do
+          @association.save
+          @parent.should_not be_new_record
+        end
+
+        it 'should return the result of the save' do
+          @association.save.should == true
+        end
+      end
+    end
+
+    describe '#reload' do
+      before do
+        @child.parent_id.should == @parent.id
+        @association.replace(@other)
+      end
+
+      it 'should not change the foreign key in the child' do
+        @child.parent_id.should == @other.id
+        @association.reload
+        @child.parent_id.should == @other.id
+      end
+
+      it 'should return self' do
+        @association.reload.object_id.should == @association.object_id
+      end
+    end
+  end
+end

data/spec/integration/associations/one_to_many_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+require 'pp'
+describe "OneToMany" do
+  before(:all) do
+    class Team
+      include DataMapper::Resource
+
+      def self.default_repository_name; ADAPTER end
+
+      property :id, Serial
+      property :name, String
+
+      has n, :players
+    end
+
+    class Player
+      include DataMapper::Resource
+
+      def self.default_repository_name; ADAPTER end
+
+      property :id, Serial
+      property :name, String
+
+      belongs_to :team
+    end
+
+    [Team, Player].each { |k| k.auto_migrate!(ADAPTER) }
+
+    Team.create!(:name => "Cowboys")
+  end
+
+  it "unsaved parent model should accept array of hashes for association" do
+    players = [{ :name => "Brett Favre" }, { :name => "Reggie White" }]
+
+    team = Team.new(:name => "Packers", :players => players)
+    team.players.zip(players) do |player, values|
+      player.should be_an_instance_of(Player)
+      values.each { |k, v| player.send(k).should == v }
+    end
+
+    players = team.players
+    team.save
+
+    repository(ADAPTER) do
+      Team.get(2).players.should == players
+    end
+  end
+
+  it "saved parent model should accept array of hashes for association" do
+    players = [{ :name => "Troy Aikman" }, { :name => "Chad Hennings" }]
+
+    team = Team.get(1)
+    team.players = players
+    team.players.zip(players) do |player, values|
+      player.should be_an_instance_of(Player)
+      values.each { |k, v| player.send(k).should == v }
+    end
+
+    players = team.players
+    team.save
+
+    repository(ADAPTER) do
+      Team.get(1).players.should == players
+    end
+  end
+end