sbf-dm-core 1.3.0.beta

data/spec/semipublic/adapters/abstract_adapter_spec.rb

@@ -0,0 +1,30 @@
+require_relative '../../spec_helper'
+
+describe 'AbstractAdapter' do
+  before :all do
+    @adapter = DataMapper::Adapters::AbstractAdapter.new(:abstract, :foo => 'bar')
+    @adapter_class = @adapter.class
+    @scheme        = DataMapper::Inflector.underscore(DataMapper::Inflector.demodulize(@adapter_class).chomp('Adapter'))
+    @adapter_name  = "test_#{@scheme}".to_sym
+  end
+
+  describe 'initialization' do
+
+    describe 'name' do
+      it 'has a name' do
+        expect(@adapter.name).to eq :abstract
+      end
+    end
+
+    it 'sets options' do
+      expect(@adapter.options).to eq({foo: 'bar'})
+    end
+
+    it 'sets naming conventions' do
+      expect(@adapter.resource_naming_convention).to eq DataMapper::NamingConventions::Resource::UnderscoredAndPluralized
+      expect(@adapter.field_naming_convention).to eq DataMapper::NamingConventions::Field::Underscored
+    end
+
+  end
+
+end

data/spec/semipublic/adapters/in_memory_adapter_spec.rb

@@ -0,0 +1,13 @@
+require_relative '../../spec_helper'
+require 'dm-core/spec/shared/adapter_spec'
+
+describe 'Adapter' do
+  supported_by :in_memory do
+    describe 'DataMapper::Adapters::InMemoryAdapter' do
+      let(:adapter)    { DataMapper::Spec.adapter }
+      let(:repository) { DataMapper.repository(adapter.name) }
+
+      it_behaves_like 'An Adapter'
+    end
+  end
+end

data/spec/semipublic/associations/many_to_many_spec.rb

@@ -0,0 +1,94 @@
+require_relative '../../spec_helper'
+
+describe 'Many to Many Associations' do
+  before :all do
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+
+        property :title, String, :key => true
+        property :body,  Text,   :required => true
+
+        has n, :without_default_join,       'WithoutDefault'
+        has n, :with_default_join,          'WithDefault'
+        has n, :with_default_callable_join, 'WithDefaultCallable'
+      end
+
+      class Author
+        include DataMapper::Resource
+
+        property :name, String, :key => true
+
+        has n, :without_default_join,       'WithoutDefault'
+        has n, :with_default_join,          'WithDefault'
+        has n, :with_default_callable_join, 'WithDefaultCallable'
+
+        has n, :without_default,       'Article', :through => :without_default_join,       :via => :article
+        has n, :with_default,          'Article', :through => :with_default_join,          :via => :article
+        has n, :with_default_callable, 'Article', :through => :with_default_callable_join, :via => :article
+      end
+
+      class WithoutDefault
+        include DataMapper::Resource
+
+        belongs_to :article, :key => true
+        belongs_to :author,  :key => true
+      end
+
+      class WithDefault
+        include DataMapper::Resource
+
+        belongs_to :article, :key => true
+        belongs_to :author,  :key => true
+      end
+
+      class WithDefaultCallable
+        include DataMapper::Resource
+
+        belongs_to :article, :key => true
+        belongs_to :author,  :key => true
+      end
+    end
+
+
+    @article_model = Blog::Article
+    @author_model  = Blog::Author
+
+    DataMapper.finalize
+
+    n = @article_model.n
+
+    @default_value          = [ @author_model.new(:name => 'Dan Kubb') ]
+    @default_value_callable = [ @author_model.new(:name => 'John Doe') ]
+
+    @subject_without_default       = @article_model.has(n, :without_default,       'Author', :through => :without_default_join,       :via => :author)
+    @subject_with_default          = @article_model.has(n, :with_default,          'Author', :through => :with_default_join,          :via => :author, :default => @default_value)
+    @subject_with_default_callable = @article_model.has(n, :with_default_callable, 'Author', :through => :with_default_callable_join, :via => :author, :default => lambda { |resource, relationship| @default_value_callable })
+
+    DataMapper.finalize
+  end
+
+  supported_by :all do
+    before :all do
+      @no_join = defined?(DataMapper::Adapters::InMemoryAdapter) && @adapter.kind_of?(DataMapper::Adapters::InMemoryAdapter) ||
+                 defined?(DataMapper::Adapters::YamlAdapter)     && @adapter.kind_of?(DataMapper::Adapters::YamlAdapter)
+    end
+
+    before do
+      pending if @no_join
+    end
+
+    before :all do
+      @default_value.each { |resource| resource.save }
+      @default_value_callable.each { |resource| resource.save }
+    end
+
+    describe 'acts like a subject' do
+      before do
+        @resource = @article_model.new(:title => 'DataMapper Rocks!', :body => 'TSIA')
+      end
+
+      it_behaves_like 'A semipublic Subject'
+    end
+  end
+end

data/spec/semipublic/associations/many_to_one_spec.rb

@@ -0,0 +1,63 @@
+require_relative '../../spec_helper'
+
+describe 'Many to One Associations' do
+  before :all do
+    class ::User
+      include DataMapper::Resource
+
+      property :name,        String, :key => true
+      property :age,         Integer
+      property :description, Text
+
+      has n, :comments
+    end
+
+    class ::Comment
+      include DataMapper::Resource
+
+      property :id, Serial
+
+      belongs_to :user
+    end
+
+    @user_model    = User
+    @comment_model = Comment
+
+    DataMapper.finalize
+
+    @default_value          = @user_model.new(:name => 'dkubb', :age => 34, :description => 'Test')
+    @default_value_callable = @user_model.new(:name => 'jdoe',  :age => 21, :description => 'Test')
+
+    @subject_without_default       = @user_model.belongs_to(:without_default,       @user_model, :required => false, :child_key => [ :without_default_id       ])
+    @subject_with_default          = @user_model.belongs_to(:with_default,          @user_model, :required => false, :child_key => [ :with_default_id          ], :default => @default_value)
+    @subject_with_default_callable = @user_model.belongs_to(:with_default_callable, @user_model, :required => false, :child_key => [ :with_default_callable_id ], :default => lambda { |resource, relationship| @default_value_callable })
+
+    @default_value.with_default          = nil
+    @default_value.with_default_callable = nil
+
+    DataMapper.finalize
+  end
+
+  supported_by :all do
+    before :all do
+      @default_value.save
+      @default_value_callable.save
+    end
+
+    before :all do
+      comment = @comment_model.create(:user => { :name => 'dbussink', :age => 25, :description => 'Test' })
+
+      @user = @comment_model.get(*comment.key).user
+    end
+
+    it_behaves_like 'A semipublic Resource'
+
+    describe 'acts like a subject' do
+      before do
+        @resource = @user_model.new(:name => 'A subject')
+      end
+
+      it_behaves_like 'A semipublic Subject'
+    end
+  end
+end

data/spec/semipublic/associations/one_to_many_spec.rb

@@ -0,0 +1,55 @@
+require_relative '../../spec_helper'
+
+describe 'One to Many Associations' do
+  before :all do
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+
+        property :title, String, :key => true
+        property :body,  Text,   :required => true
+      end
+
+      class Author
+        include DataMapper::Resource
+
+        property :name, String, :key => true
+
+        belongs_to :without_default,       'Article', :child_key => [ :without_default_id       ], :required => false
+        belongs_to :with_default,          'Article', :child_key => [ :with_default_id          ], :required => false
+        belongs_to :with_default_callable, 'Article', :child_key => [ :with_default_callable_id ], :required => false
+      end
+    end
+
+    @article_model = Blog::Article
+    @author_model  = Blog::Author
+
+    DataMapper.finalize
+
+    n = @article_model.n
+
+    @default_value          = [ @author_model.new(:name => 'Dan Kubb') ]
+    @default_value_callable = [ @author_model.new(:name => 'John Doe') ]
+
+    @subject_without_default       = @article_model.has(n, :without_default,       @author_model, :child_key => [ :without_default_id       ])
+    @subject_with_default          = @article_model.has(n, :with_default,          @author_model, :child_key => [ :with_default_id          ], :default => @default_value)
+    @subject_with_default_callable = @article_model.has(n, :with_default_callable, @author_model, :child_key => [ :with_default_callable_id ], :default => lambda { |resource, relationship| @default_value_callable })
+
+    DataMapper.finalize
+  end
+
+  supported_by :all do
+    before :all do
+      @default_value.each { |resource| resource.save }
+      @default_value_callable.each { |resource| resource.save }
+    end
+
+    describe 'acts like a subject' do
+      before do
+        @resource = @article_model.new(:title => 'DataMapper Rocks!', :body => 'TSIA')
+      end
+
+      it_behaves_like 'A semipublic Subject'
+    end
+  end
+end

data/spec/semipublic/associations/one_to_one_spec.rb

@@ -0,0 +1,53 @@
+require_relative '../../spec_helper'
+
+describe 'One to One Associations' do
+  before :all do
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+
+        property :title, String, :key => true
+        property :body,  Text,   :required => true
+      end
+
+      class Author
+        include DataMapper::Resource
+
+        property :name, String, :key => true
+
+        belongs_to :without_default,       'Article', :child_key => [ :without_default_id       ], :required => false
+        belongs_to :with_default,          'Article', :child_key => [ :with_default_id          ], :required => false
+        belongs_to :with_default_callable, 'Article', :child_key => [ :with_default_callable_id ], :required => false
+      end
+    end
+
+    @article_model = Blog::Article
+    @author_model  = Blog::Author
+
+    DataMapper.finalize
+
+    @default_value          = @author_model.new(:name => 'Dan Kubb')
+    @default_value_callable = @author_model.new(:name => 'John Doe')
+
+    @subject_without_default       = @article_model.has(1, :without_default,       @author_model, :child_key => [ :without_default_id       ])
+    @subject_with_default          = @article_model.has(1, :with_default,          @author_model, :child_key => [ :with_default_id          ], :default => @default_value)
+    @subject_with_default_callable = @article_model.has(1, :with_default_callable, @author_model, :child_key => [ :with_default_callable_id ], :default => lambda { |resource, relationship| @default_value_callable })
+
+    DataMapper.finalize
+  end
+
+  supported_by :all do
+    before :all do
+      @default_value.save
+      @default_value_callable.save
+    end
+
+    describe 'acts like a subject' do
+      before do
+        @resource = @article_model.new(:title => 'DataMapper Rocks!', :body => 'TSIA')
+      end
+
+      it_behaves_like 'A semipublic Subject'
+    end
+  end
+end

data/spec/semipublic/associations/relationship_spec.rb

@@ -0,0 +1,200 @@
+require_relative '../../spec_helper'
+
+describe DataMapper::Associations::Relationship do
+  before :all do
+    module ::Blog
+      class Article
+        include DataMapper::Resource
+
+        property :title, String, :key => true
+      end
+
+      class Comment
+        include DataMapper::Resource
+
+        property :id,   Serial
+        property :body, Text
+      end
+    end
+
+    @article_model = Blog::Article
+    @comment_model = Blog::Comment
+  end
+
+  def n
+    1.0/0
+  end
+
+  describe '#inverse' do
+    describe 'with matching relationships' do
+      before :all do
+        @comments_relationship = @article_model.has(n, :comments)
+        @article_relationship  = @comment_model.belongs_to(:article)
+
+        # TODO: move this to spec/public/model/relationship_spec.rb
+        expect(@comments_relationship.child_repository_name).to be_nil
+        expect(@comments_relationship.parent_repository_name).to eq :default
+
+        # TODO: move this to spec/public/model/relationship_spec.rb
+        expect(@article_relationship.child_repository_name).to eq :default
+        expect(@article_relationship.parent_repository_name).to be_nil
+        DataMapper.finalize
+      end
+
+      it 'returns the inverted relationships' do
+        expect(@comments_relationship.inverse).to equal(@article_relationship)
+        expect(@article_relationship.inverse).to equal(@comments_relationship)
+      end
+    end
+
+    describe 'with matching relationships where the child repository is not nil' do
+      before :all do
+        @comments_relationship = @article_model.has(n, :comments, :repository => :default)
+        @article_relationship  = @comment_model.belongs_to(:article)
+
+        # TODO: move this to spec/public/model/relationship_spec.rb
+        expect(@comments_relationship.child_repository_name).to eq :default
+        expect(@comments_relationship.parent_repository_name).to eq :default
+
+        # TODO: move this to spec/public/model/relationship_spec.rb
+        expect(@article_relationship.child_repository_name).to eq :default
+        expect(@article_relationship.parent_repository_name).to be_nil
+        DataMapper.finalize
+      end
+
+      it 'returns the inverted relationships' do
+        expect(@comments_relationship.inverse).to equal(@article_relationship)
+        expect(@article_relationship.inverse).to equal(@comments_relationship)
+      end
+    end
+
+    describe 'with matching relationships where the parent repository is not nil' do
+      before :all do
+        @comments_relationship = @article_model.has(n, :comments)
+        @article_relationship  = @comment_model.belongs_to(:article, :repository => :default)
+
+        # TODO: move this to spec/public/model/relationship_spec.rb
+        expect(@comments_relationship.child_repository_name).to be_nil
+        expect(@comments_relationship.parent_repository_name).to eq :default
+
+        # TODO: move this to spec/public/model/relationship_spec.rb
+        expect(@article_relationship.child_repository_name).to eq :default
+        expect(@article_relationship.parent_repository_name).to eq :default
+        DataMapper.finalize
+      end
+
+      it 'returns the inverted relationships' do
+        expect(@comments_relationship.inverse).to equal(@article_relationship)
+        expect(@article_relationship.inverse).to equal(@comments_relationship)
+      end
+    end
+
+    describe 'with no matching relationship', 'from the parent side' do
+      before :all do
+        # added to force OneToMany::Relationship#inverse to consider the
+        # child_key differences
+        @comment_model.belongs_to(:other_article, @article_model, :child_key => [ :other_article_id ])
+
+        @relationship = @article_model.has(n, :comments)
+
+        @inverse = @relationship.inverse
+
+        # after Relationship#inverse to ensure no match
+        @expected = @comment_model.belongs_to(:article)
+        DataMapper.finalize
+      end
+
+      it 'returns a Relationship' do
+        expect(@inverse).to be_kind_of(DataMapper::Associations::Relationship)
+      end
+
+      it 'returns an inverted relationship' do
+        expect(@inverse).to eq @expected
+      end
+
+      it 'is an anonymous relationship' do
+        expect(@inverse).not_to equal(@expected)
+      end
+
+      it 'has a source repository equal to the target repository of the relationship' do
+        expect(@inverse.source_repository_name).to eq @relationship.target_repository_name
+      end
+
+      it "has the relationship as it's inverse" do
+        expect(@inverse.inverse).to equal(@relationship)
+      end
+    end
+
+    describe 'with no matching relationship', 'from the child side' do
+      before :all do
+        @relationship = @comment_model.belongs_to(:article)
+
+        @inverse = @relationship.inverse
+
+        # after Relationship#inverse to ensure no match
+        @expected = @article_model.has(n, :comments)
+        DataMapper.finalize
+      end
+
+      it 'returns a Relationship' do
+        expect(@inverse).to be_kind_of(DataMapper::Associations::Relationship)
+      end
+
+      it 'returns an inverted relationship' do
+        expect(@inverse).to eq @expected
+      end
+
+      it 'is an anonymous relationship' do
+        expect(@inverse).not_to equal(@expected)
+      end
+
+      it 'has a source repository equal to the target repository of the relationship' do
+        expect(@inverse.source_repository_name).to eq @relationship.target_repository_name
+      end
+
+      it "has the relationship as it's inverse" do
+        expect(@inverse.inverse).to equal(@relationship)
+      end
+    end
+  end
+
+  describe '#valid?' do
+    before :all do
+      @relationship = @article_model.has(n, :comments)
+      DataMapper.finalize
+    end
+
+    supported_by :all do
+      describe 'with valid resource' do
+        before :all do
+          @article  = @article_model.create(:title => 'Relationships in DataMapper')
+          @resource = @article.comments.create
+        end
+
+        it 'returns true' do
+          expect(@relationship.valid?(@resource)).to be(true)
+        end
+      end
+
+      describe 'with a resource of the wrong class' do
+        before :all do
+          @resource  = @article_model.new
+        end
+
+        it 'returns false' do
+          expect(@relationship.valid?(@resource)).to be(false)
+        end
+      end
+
+      describe 'with a resource without a valid parent' do
+        before :all do
+          @resource = @comment_model.new
+        end
+
+        it 'returns false' do
+          expect(@relationship.valid?(@resource)).to be(false)
+        end
+      end
+    end
+  end
+end

data/spec/semipublic/associations_spec.rb

@@ -0,0 +1,177 @@
+require 'spec_helper'
+
+describe DataMapper::Associations do
+  before :all do
+    class ::Car
+      include DataMapper::Resource
+
+      property :id, Serial
+    end
+
+    class ::Engine
+      include DataMapper::Resource
+
+      property :id, Serial
+    end
+
+    class ::Door
+      include DataMapper::Resource
+
+      property :id, Serial
+    end
+
+    class ::Window
+      include DataMapper::Resource
+
+      property :id, Serial
+    end
+  end
+
+  def n
+    1.0/0
+  end
+
+  describe '#has' do
+    describe '1' do
+      before :all do
+        @relationship = Car.has(1, :engine)
+      end
+
+      it 'returns a Relationship' do
+        expect(@relationship).to be_a_kind_of(DataMapper::Associations::OneToOne::Relationship)
+      end
+
+      it 'returns a Relationship with the child model' do
+        expect(@relationship.child_model).to eq Engine
+      end
+
+      it 'returns a Relationship with a min of 1' do
+        expect(@relationship.min).to eq 1
+      end
+
+      it 'returns a Relationship with a max of 1' do
+        expect(@relationship.max).to eq 1
+      end
+    end
+
+    describe 'n..n' do
+      before :all do
+        @relationship = Car.has(1..4, :doors)
+      end
+
+      it 'returns a Relationship' do
+        expect(@relationship).to be_a_kind_of(DataMapper::Associations::OneToMany::Relationship)
+      end
+
+      it 'returns a Relationship with the child model' do
+        expect(@relationship.child_model).to eq Door
+      end
+
+      it 'returns a Relationship with a min of 1' do
+        expect(@relationship.min).to eq 1
+      end
+
+      it 'returns a Relationship with a max of 4' do
+        expect(@relationship.max).to eq 4
+      end
+    end
+
+    describe 'n..n through' do
+      before :all do
+        Door.has(1, :window)
+        Car.has(1..4, :doors)
+
+        @relationship = Car.has(1..4, :windows, :through => :doors)
+      end
+
+      it 'returns a Relationship' do
+        expect(@relationship).to be_a_kind_of(DataMapper::Associations::ManyToMany::Relationship)
+      end
+
+      it 'returns a Relationship with the child model' do
+        expect(@relationship.child_model).to eq Window
+      end
+
+      it 'returns a Relationship with a min of 1' do
+        expect(@relationship.min).to eq 1
+      end
+
+      it 'returns a Relationship with a max of 4' do
+        expect(@relationship.max).to eq 4
+      end
+    end
+
+    describe 'n' do
+      before :all do
+        @relationship = Car.has(n, :doors)
+      end
+
+      it 'returns a Relationship' do
+        expect(@relationship).to be_a_kind_of(DataMapper::Associations::OneToMany::Relationship)
+      end
+
+      it 'returns a Relationship with the child model' do
+        expect(@relationship.child_model).to eq Door
+      end
+
+      it 'returns a Relationship with a min of 0' do
+        expect(@relationship.min).to eq 0
+      end
+
+      it 'returns a Relationship with a max of n' do
+        expect(@relationship.max).to eq n
+      end
+    end
+
+    describe 'n through' do
+      before :all do
+        Door.has(1, :windows)
+        Car.has(1..4, :doors)
+
+        @relationship = Car.has(n, :windows, :through => :doors)
+      end
+
+      it 'returns a Relationship' do
+        expect(@relationship).to be_a_kind_of(DataMapper::Associations::ManyToMany::Relationship)
+      end
+
+      it 'returns a Relationship with the child model' do
+        expect(@relationship.child_model).to eq Window
+      end
+
+      it 'returns a Relationship with a min of 0' do
+        expect(@relationship.min).to eq 0
+      end
+
+      it 'returns a Relationship with a max of n' do
+        expect(@relationship.max).to eq n
+      end
+    end
+  end
+
+  describe '#belongs_to' do
+    before :all do
+      @relationship = Engine.belongs_to(:car)
+    end
+
+    it 'returns a Relationship' do
+      expect(@relationship).to be_a_kind_of(DataMapper::Associations::ManyToOne::Relationship)
+    end
+
+    it 'returns a Relationship with the parent model' do
+      expect(@relationship.parent_model).to eq Car
+    end
+
+    it 'returns a Relationship with a min of 1' do
+      expect(@relationship.min).to eq 1
+    end
+
+    it 'returns a Relationship with a max of 1' do
+      expect(@relationship.max).to eq 1
+    end
+
+    it 'returns a Relationship that is required' do
+      expect(@relationship.required?).to be(true)
+    end
+  end
+end