ninja-model 0.8.1 → 0.9.0

data/spec/lib/ninja_model/associations/belongs_to_association_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe NinjaModel::Associations::BelongsToAssociation do
+  let(:user) { Factory(:user) }
+  let(:post) { Factory(:post, :user_id => user.id) }
+
+  context 'with an ActiveRecord parent' do
+    describe 'accessing the association directly' do
+      it 'should return an instance' do
+        post.user.should eql(user)
+      end
+    end
+
+    describe 'assigning an instance' do
+      it 'should update the associated id' do
+        post.user = user
+        post.user_id.should eql(user.id)
+      end
+    end
+
+    it 'should raise an exception when trying to assign the wrong class' do
+      lambda { post.user = Tag.new }.should raise_error
+    end
+  end
+
+  context 'with a NinjaModel parent' do
+    context 'and an ActiveRecord child' do
+      describe 'accessing the association directly' do
+        it 'should trigger a fetch' do
+          NinjaModel::Relation.any_instance.expects(:to_a).returns(post)
+          t = Tag.new(:post_id => post.id)
+          t.post
+        end
+
+        it 'should assign the proper predicates' do
+          t = Tag.new(:post_id => post.id)
+          predicates = t.association(:post).scoped.predicates
+          predicates.count.should eql(1)
+          predicates.first.attribute.should eql(:id)
+          predicates.first.meth.should eql(:eq)
+          predicates.first.value.should eql(post.id)
+        end
+      end
+    end
+
+    context 'and a NinjaModel child' do
+      describe 'accessing the association directly' do
+        it 'should trigger a fetch' do
+          NinjaModel::Relation.any_instance.expects(:to_a).returns(post)
+          c = Category.new(:post_id => post.id)
+          c.post
+        end
+
+        it 'should assign the proper predicates' do
+          c = Category.new(:post_id => post.id)
+          predicates = c.association(:post).scoped.predicates
+          predicates.count.should eql(1)
+          predicates.first.attribute.should eql(:id)
+          predicates.first.meth.should eql(:eq)
+          predicates.first.value.should eql(post.id)
+        end
+      end
+    end
+
+    it 'should raise an exception when trying to assign the wrong class' do
+      t = Tag.new
+      lambda { t.post = user }.should raise_error
+    end
+
+    it 'should properly update the ids when assigning a new instance' do
+      t = Factory(:tag)
+      t.post = post
+      t.post_id.should eql(post.id)
+    end
+  end
+end

data/spec/lib/ninja_model/associations/has_many_association_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+describe NinjaModel::Associations::HasManyAssociation do
+  let(:user) { Factory(:user) }
+
+  context 'with an ActiveRecord parent' do
+
+    describe 'accessing the association directly' do
+      it 'should return a CollectionProxy' do
+        user.posts.should be_kind_of(NinjaModel::Associations::CollectionProxy)
+      end
+    end
+
+    describe 'first' do
+      it 'should trigger a fetch' do
+        NinjaModel::Relation.any_instance.expects(:to_a).returns([])
+        user.posts.first.should
+      end
+    end
+
+    describe 'adding a scope' do
+      it 'should return a NinjaModel::Relation' do
+        user.posts.published.should be_kind_of(NinjaModel::Relation)
+      end
+      it 'should have the correct predicates' do
+        predicates = user.posts.published.predicates
+        predicates.count.should eql(2)
+
+        predicates.first.attribute.should eql(:user_id)
+        predicates.first.meth.should eql(:eq)
+        predicates.first.value.should eql(user.id)
+
+        predicates.last.attribute.should eql(:published)
+        predicates.last.meth.should eql(:eq)
+        predicates.last.value.should eql(true)
+      end
+    end
+
+    describe 'building an associated object' do
+      it 'should return an unitialized object' do
+        user.posts.build.should be_kind_of(Post)
+      end
+      it 'should already belong to the user' do
+        user.posts.build.user.id.should eql(user.id)
+      end
+    end
+  end
+
+  context 'with a NinjaModel parent' do
+
+    let(:post) { Factory(:post) }
+    let!(:tags) { FactoryGirl.create_list(:tag, 2, :post_id => 1) }
+
+    context 'and an ActiveRecord association' do
+      it 'should return an Array' do
+        post.tags.should be_kind_of(Array)
+      end
+
+      it 'should retrieve the proper associated objects' do
+        post.tags.count.should be > 0
+      end
+
+      it 'should allow chaining queries' do
+        post.tags.where(:name => 'Tag 2').count.should eql(1)
+      end
+
+      describe 'building an associated object' do
+        it 'should return an unitialized object' do
+          post.tags.build.should be_kind_of(Tag)
+        end
+        it 'should already belong to the Post' do
+          post.tags.build.post_id.should eql(post.id)
+        end
+      end
+    end
+
+    context 'and a NinjaModel association' do
+      it 'should return a CollectionProxy' do
+        post.categories.should be_kind_of(NinjaModel::Associations::CollectionProxy)
+      end
+
+      it 'should assign the proper predicates' do
+        predicates = post.categories.scoped.predicates
+        predicates.count.should eql(1)
+        predicates.first.attribute.should eql(:post_id)
+        predicates.first.meth.should eql(:eq)
+        predicates.first.value.should eql(1)
+      end
+
+      it 'should allow chaining' do
+        predicates = post.categories.where(:name => 'foo').predicates
+        predicates.count.should eql(2)
+        predicates.first.attribute.should eql(:post_id)
+        predicates.first.meth.should eql(:eq)
+        predicates.first.value.should eql(1)
+        predicates.last.attribute.should eql(:name)
+        predicates.last.meth.should eql(:eq)
+        predicates.last.value.should eql('foo')
+      end
+
+      describe 'accessing the collection' do
+        it 'should trigger a fetch' do
+          NinjaModel::Relation.any_instance.expects(:to_a).returns([])
+          post.categories.count
+        end
+      end
+
+      describe 'building an associated object' do
+        it 'should return an unitialized object' do
+          post.categories.build.should be_kind_of(Category)
+        end
+        it 'should already belong to the user' do
+          post.categories.build.post_id.should eql(post.id)
+        end
+      end
+    end
+  end
+end

data/spec/lib/ninja_model/associations/has_one_association_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe NinjaModel::Associations::HasOneAssociation do
+  let(:user) { Factory(:user) }
+  let(:post) { Factory(:post, :user_id => user.id) }
+  let(:bio) { Factory(:bio, :user_id => user.id) }
+
+  context 'with an ActiveRecord parent' do
+    describe 'accessing the association directly' do
+      it 'should trigger a fetch' do
+        NinjaModel::Relation.any_instance.expects(:to_a).returns([bio])
+        user.bio.name.should eql(bio.name)
+      end
+    end
+
+    it 'should assign the proper predicates' do
+      predicates = user.association(:bio).scoped.predicates
+      predicates.count.should eql(1)
+      predicates.first.attribute.should eql(:user_id)
+      predicates.first.meth.should eql(:eq)
+      predicates.first.value.should eql(user.id)
+    end
+  end
+
+  context 'with a NinjaModel parent' do
+    context 'and an ActiveRecord child' do
+      let!(:email_address) { Factory(:email_address, :bio_id => bio.id) }
+      describe 'accessing the association directly' do
+        it 'should retrieve the record' do
+          bio.email_address.should be_kind_of(EmailAddress)
+        end
+      end
+
+      it 'should allow building the association' do
+        email = bio.build_email_address
+        email.should be_kind_of(EmailAddress)
+        email.bio_id.should eql(bio.id)
+      end
+
+      it 'should allow creating the association' do
+        bio.create_email_address(:email => 'foo@bar.com').should be_true
+      end
+    end
+
+    context 'and a NinjaModel child' do
+      let(:body) { Factory(:body, :post_id => post.id) }
+      describe 'accessing the association directly' do
+        it 'should trigger a fetch' do
+          NinjaModel::Relation.any_instance.expects(:to_a).returns([body])
+          post.body
+        end
+
+        it 'should assign the proper predicates' do
+          predicates = post.association(:body).scoped.predicates
+          predicates.count.should eql(1)
+          predicates.first.attribute.should eql(:post_id)
+          predicates.first.meth.should eql(:eq)
+          predicates.first.value.should eql(post.id)
+        end
+      end
+
+      it 'should allow building the association' do
+        #
+        # We have to stub to_a here because building will try and retrieve the
+        # existing record to remove ownership
+        #
+        NinjaModel::Relation.any_instance.stubs(:to_a).returns([])
+        body = post.build_body
+        body.should be_kind_of(Body)
+        body.post_id.should eql(post.id)
+      end
+
+      it 'should allow creating the association' do
+        NinjaModel::Relation.any_instance.stubs(:to_a).returns([])
+        Body.any_instance.stubs(:create).returns(true)
+        post.create_body(:text => 'Foobar')
+      end
+    end
+  end
+end

data/spec/{ninja_model → lib/ninja_model}/attribute_methods_spec.rb

@@ -5,8 +5,8 @@ describe NinjaModel::AttributeMethods do
     attribute :test, :string
   end
   subject { AttributeModel.new }
-  specify { subject.attribute_method?(:test).should be_true }
-  specify { subject.attribute_method?(:invalid).should be_false }
+  specify { subject.send(:attribute_method?, 'test').should be_true }
+  specify { subject.send(:attribute_method?, 'invalid').should be_false }
 
   it 'should return a list of valid attribute names' do
     AttributeModel.attribute_names.should eql(['test'])

data/spec/{ninja_model → lib/ninja_model}/attribute_spec.rb

@@ -8,6 +8,10 @@ describe NinjaModel::Attribute do
   RSpec::Matchers.define :convert do |input|
     chain :to do |expected|
       @expected = expected
+
+      failure_message_for_should do |attr|
+        "convert(#{input.inspect}) should be #{@expected.inspect}, but got #{@actual.inspect}"
+      end
     end
 
     match do |attr|

data/spec/{ninja_model → lib/ninja_model}/reflection_spec.rb

@@ -14,15 +14,13 @@ describe NinjaModel::Reflection do
 
   describe 'create_reflection' do
     it 'should store the reflections on the class' do
-      @klass = Class.new(NinjaModel::Base)
-      @reflection = @klass.create_reflection(:has_one, :target_model, {}, @klass)
-      @klass.reflections.should eql(:target_model => @reflection)
+      @reflection = ReflectionModel.create_reflection(:has_one, :target_model, {}, TargetModel)
+      ReflectionModel.reflections.should eql(:target_model => @reflection)
     end
 
     it 'should return a reflection for a particular association' do
-      @klass = Class.new(NinjaModel::Base)
-      @reflection = @klass.create_reflection(:has_one, :target_model, {}, @klass)
-      @klass.reflect_on_association(:target_model).should eql(@reflection)
+      @reflection = ReflectionModel.create_reflection(:has_one, :target_model, {}, TargetModel)
+      ReflectionModel.reflect_on_association(:target_model).should eql(@reflection)
     end
 
     context 'has_one' do
@@ -30,7 +28,7 @@ describe NinjaModel::Reflection do
       its(:class_name) { should eql('TargetModel') }
       its(:klass) { should eql(TargetModel) }
       its(:collection?) { should be_false }
-      its(:primary_key_name) { should eql('reflection_model_id') }
+      its(:foreign_key) { should eql('reflection_model_id') }
       its(:association_foreign_key) { should eql('target_model_id') }
       its(:belongs_to?) { should be_false }
     end
@@ -40,7 +38,7 @@ describe NinjaModel::Reflection do
       its(:class_name) { should eql('TargetModel') }
       its(:klass) { should eql(TargetModel) }
       its(:collection?) { should be_true }
-      its(:primary_key_name) { should eql('reflection_model_id') }
+      its(:foreign_key) { should eql('reflection_model_id') }
       its(:association_foreign_key) { should eql('target_model_id') }
       its(:belongs_to?) { should be_false }
     end
@@ -50,7 +48,7 @@ describe NinjaModel::Reflection do
       its(:class_name) { should eql('ReflectionModel') }
       its(:klass) { should eql(ReflectionModel) }
       its(:collection?) { should be_false }
-      its(:primary_key_name) { should eql('reflection_model_id') }
+      its(:foreign_key) { should eql('reflection_model_id') }
       its(:association_foreign_key) { should eql('reflection_model_id') }
       its(:belongs_to?) { should be_true }
     end

data/spec/models/bio.rb

@@ -0,0 +1,8 @@
+class Bio < NinjaModel::Base
+  attribute :id, :integer
+  attribute :user_id, :integer
+  attribute :name, :string
+
+  belongs_to :user
+  has_one :email_address
+end

data/spec/models/body.rb

@@ -0,0 +1,7 @@
+class Body < NinjaModel::Base
+  attribute :id, :integer, :primary_key => true
+  attribute :post_id, :integer
+  attribute :text, :string
+
+  belongs_to :post
+end

data/spec/models/category.rb

@@ -0,0 +1,7 @@
+class Category < NinjaModel::Base
+  attribute :id, :integer, :primary_key => true
+  attribute :post_id, :integer
+  attribute :name, :string
+
+  belongs_to :post
+end

data/spec/models/email_address.rb

@@ -0,0 +1,3 @@
+class EmailAddress < ActiveRecord::Base
+  belongs_to :bio
+end

data/spec/models/post.rb

@@ -0,0 +1,13 @@
+class Post < NinjaModel::Base
+  attribute :id, :integer, :primary_key => true
+  attribute :user_id, :integer
+  attribute :title, :string
+  attribute :published, :boolean
+
+  scope :published, where(:published => true)
+
+  belongs_to :user
+  has_one :body
+  has_many :tags
+  has_many :categories
+end

data/spec/models/tag.rb

@@ -0,0 +1,3 @@
+class Tag < ActiveRecord::Base
+  belongs_to :post
+end

data/spec/models/user.rb

@@ -0,0 +1,4 @@
+class User < ActiveRecord::Base
+  has_many :posts
+  has_one :bio
+end

data/spec/spec_helper.rb

@@ -1,22 +1,55 @@
+require 'rubygems'
+require 'bundler'
 require 'simplecov'
 SimpleCov.start do
   add_filter 'spec'
 end
-#Bundler.require(:default)
-require 'rspec/core'
-require 'ninja-model'
-
-Dir[File.join(File.expand_path('../', __FILE__), 'support/**/*.rb')].each { |f| require f }
+Bundler.require(:default, :test)
 
 RSpec.configure do |config|
   config.mock_with :mocha
 end
 
+
+def init_active_record
+  db_root = File.join(File.expand_path('../', __FILE__), 'db')
+  ActiveRecord::Base.configurations['test'] = {
+    'adapter' => 'sqlite3',
+    'database' => File.join(db_root, 'test.sqlite3'),
+    'pool' => 5,
+    'timeout' => 5000
+  }
+  ActiveRecord::Base.establish_connection(:test)
+
+  schema_file = File.join(File.expand_path('../', __FILE__), 'db', 'schema.rb')
+  load schema_file
+end
+
+init_active_record
+
 class DummyLogger
   def debug(*args)
+    #puts "*** DEBUG ***"
+    #puts args
   end
   def warn(*args)
+    puts "*** WARNING ***"
+    puts args
+  end
+
+  def error(*args)
+    puts "*** ERROR ***"
+    puts args
+  end
+
+  def debug?
+    true
   end
 end
 
 NinjaModel.set_logger(DummyLogger.new)
+ActiveRecord::Base.logger = DummyLogger.new
+
+ActiveSupport::Dependencies.autoload_paths << File.join(File.expand_path('../', __FILE__), 'models')
+
+Dir[File.join(File.expand_path('../', __FILE__), 'support/**/*.rb')].each { |f| require f }