schema_associations 0.1.0.pre1

data/spec/association_spec.rb

@@ -0,0 +1,543 @@
+
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe ActiveRecord::Base do
+
+  after(:each) do
+    remove_all_models
+  end
+
+  context "in basic case" do
+    before(:each) do
+      create_tables(
+        "posts", {}, {},
+        "comments", {}, { :post_id => {} }
+      )
+      class Post < ActiveRecord::Base ; end
+      class Comment < ActiveRecord::Base ; end
+    end
+
+    after(:each) do
+      Comment.destroy_all
+      Post.destroy_all
+    end
+
+    it "should create belongs_to association when reflecting on it" do
+      reflection = Comment.reflect_on_association(:post)
+      reflection.should_not be_nil
+      reflection.macro.should == :belongs_to
+      reflection.options[:class_name].should == "Post"
+      reflection.options[:foreign_key].should == "post_id"
+    end
+
+    it "should create association when reflecting on all associations" do
+      reflection = Comment.reflect_on_all_associations.first
+      reflection.should_not be_nil
+      reflection.macro.should == :belongs_to
+      reflection.options[:class_name].should == "Post"
+      reflection.options[:foreign_key].should == "post_id"
+    end
+
+    it "should create association when accessing it" do
+      post = Post.create
+      comment = Comment.create(:post_id => post.id)
+      comment.post.id.should == post.id
+    end
+
+    it "should create association when creating record" do
+      post = Post.create
+      comment = Comment.create(:post => post)
+      comment.reload.post.id.should == post.id
+    end
+
+    it "should create has_many association" do
+      reflection = Post.reflect_on_association(:comments)
+      reflection.should_not be_nil
+      reflection.macro.should == :has_many
+      reflection.options[:class_name].should == "Comment"
+      reflection.options[:foreign_key].should == "post_id"
+    end
+    it "shouldn't raise an exception when model is instantiated" do
+      expect { Post.new }.should_not raise_error
+    end
+  end
+
+  it "should override auto_create negatively" do
+    with_associations_auto_create(true) do
+      create_tables(
+        "posts", {}, {},
+        "comments", {}, { :post_id => {} }
+      )
+      class Post < ActiveRecord::Base
+        schema_associations :auto_create => false
+      end
+      class Comment < ActiveRecord::Base ; end
+      Post.reflect_on_association(:comments).should be_nil
+      Comment.reflect_on_association(:post).should_not be_nil
+    end
+  end
+
+  context "with multiple associations of all types" do
+    before(:each) do
+      create_tables(
+        "owners", {}, {},
+        "colors", {}, {},
+        "widgets", {}, {
+          :owner_id => {},
+        },
+        "parts", {}, { :widget_id => {} },
+        "manifests", {}, { :widget_id => { :index => {:unique => true}} },
+        "colors_widgets", {:id => false}, { :widget_id => {}, :color_id => {} }
+      )
+    end
+
+    def check_reflections(hash)
+      hash.each do |key, val|
+        reflection = Widget.reflect_on_association(key)
+        case val
+        when true then reflection.should_not be_nil
+        else           reflection.should be_nil
+        end
+      end
+    end
+
+    it "should default as expected" do
+      class Widget < ActiveRecord::Base ; end
+      check_reflections(:owner => true, :colors => true, :parts => true, :manifest => true)
+    end
+
+    it "should respect :only" do 
+      class Widget < ActiveRecord::Base
+        schema_associations :only => :owner
+      end
+      check_reflections(:owner => true, :colors => false, :parts => false, :manifest => false)
+    end
+
+    it "should respect :except" do 
+      class Widget < ActiveRecord::Base
+        schema_associations :except => :owner
+      end
+      check_reflections(:owner => false, :colors => true, :parts => true, :manifest => true)
+    end
+
+    it "should respect :only_type :belongs_to" do 
+      class Widget < ActiveRecord::Base
+        schema_associations :only_type => :belongs_to
+      end
+      check_reflections(:owner => true, :colors => false, :parts => false, :manifest => false)
+    end
+
+    it "should respect :except_type :belongs_to" do 
+      class Widget < ActiveRecord::Base
+        schema_associations :except_type => :belongs_to
+      end
+      check_reflections(:owner => false, :colors => true, :parts => true, :manifest => true)
+    end
+
+    it "should respect :only_type :has_many" do 
+      class Widget < ActiveRecord::Base
+        schema_associations :only_type => :has_many
+      end
+      check_reflections(:owner => false, :colors => false, :parts => true, :manifest => false)
+    end
+
+    it "should respect :except_type :has_many" do 
+      class Widget < ActiveRecord::Base
+        schema_associations :except_type => :has_many
+      end
+      check_reflections(:owner => true, :colors => true, :parts => false, :manifest => true)
+    end
+
+    it "should respect :only_type :has_one" do 
+      class Widget < ActiveRecord::Base
+        schema_associations :only_type => :has_one
+      end
+      check_reflections(:owner => false, :colors => false, :parts => false, :manifest => true)
+    end
+
+    it "should respect :except_type :has_one" do 
+      class Widget < ActiveRecord::Base
+        schema_associations :except_type => :has_one
+      end
+      check_reflections(:owner => true, :colors => true, :parts => true, :manifest => false)
+    end
+
+    it "should respect :only_type :has_and_belongs_to_many" do 
+      class Widget < ActiveRecord::Base
+        schema_associations :only_type => :has_and_belongs_to_many
+      end
+      check_reflections(:owner => false, :colors => true, :parts => false, :manifest => false)
+    end
+
+    it "should respect :except_type :has_and_belongs_to_many" do 
+      class Widget < ActiveRecord::Base
+        schema_associations :except_type => :has_and_belongs_to_many
+      end
+      check_reflections(:owner => true, :colors => false, :parts => true, :manifest => true)
+    end
+
+  end
+
+  it "should override auto_create positively" do
+    with_associations_auto_create(false) do
+      create_tables(
+        "posts", {}, {},
+        "comments", {}, { :post_id => {} }
+      )
+      class Post < ActiveRecord::Base
+        schema_associations :auto_create => true
+      end
+      class Comment < ActiveRecord::Base ; end
+      Post.reflect_on_association(:comments).should_not be_nil
+      Comment.reflect_on_association(:post).should be_nil
+    end
+  end
+
+
+  context "with unique index" do
+    before(:each) do
+      create_tables(
+        "posts", {}, {},
+        "comments", {}, { :post_id => {:index => { :unique => true} } }
+      )
+      class Post < ActiveRecord::Base ; end
+      class Comment < ActiveRecord::Base ; end
+    end
+    it "should create has_one association" do
+      reflection = Post.reflect_on_association(:comment)
+      reflection.should_not be_nil
+      reflection.macro.should == :has_one
+      reflection.options[:class_name].should == "Comment"
+      reflection.options[:foreign_key].should == "post_id"
+    end
+  end
+
+  context "with prefixed column names" do
+    before(:each) do
+      create_tables(
+        "posts", {}, {},
+        "comments", {}, { :subject_post_id => { :references => :posts} }
+      )
+      class Post < ActiveRecord::Base ; end
+      class Comment < ActiveRecord::Base ; end
+    end
+    it "should name belongs_to according to column" do
+      reflection = Comment.reflect_on_association(:subject_post)
+      reflection.should_not be_nil
+      reflection.macro.should == :belongs_to
+      reflection.options[:class_name].should == "Post"
+      reflection.options[:foreign_key].should == "subject_post_id"
+    end
+
+    it "should name has_many using 'as column'" do
+      reflection = Post.reflect_on_association(:comments_as_subject)
+      reflection.should_not be_nil
+      reflection.macro.should == :has_many
+      reflection.options[:class_name].should == "Comment"
+      reflection.options[:foreign_key].should == "subject_post_id"
+    end
+  end
+
+  context "with suffixed column names" do
+    before(:each) do
+      create_tables(
+        "posts", {}, {},
+        "comments", {}, { :post_cited => { :references => :posts} }
+      )
+      class Post < ActiveRecord::Base ; end
+      class Comment < ActiveRecord::Base ; end
+    end
+    it "should name belongs_to according to column" do
+      reflection = Comment.reflect_on_association(:post_cited)
+      reflection.should_not be_nil
+      reflection.macro.should == :belongs_to
+      reflection.options[:class_name].should == "Post"
+      reflection.options[:foreign_key].should == "post_cited"
+    end
+
+    it "should name has_many using 'as column'" do
+      reflection = Post.reflect_on_association(:comments_as_cited)
+      reflection.should_not be_nil
+      reflection.macro.should == :has_many
+      reflection.options[:class_name].should == "Comment"
+      reflection.options[:foreign_key].should == "post_cited"
+    end
+  end
+
+  context "with arbitrary column names" do
+    before(:each) do
+      create_tables(
+        "posts", {}, {},
+        "comments", {}, { :subject => {:references => :posts} }
+      )
+      class Post < ActiveRecord::Base ; end
+      class Comment < ActiveRecord::Base ; end
+    end
+    it "should name belongs_to according to column" do
+      reflection = Comment.reflect_on_association(:subject)
+      reflection.should_not be_nil
+      reflection.macro.should == :belongs_to
+      reflection.options[:class_name].should == "Post"
+      reflection.options[:foreign_key].should == "subject"
+    end
+
+    it "should name has_many using 'as column'" do
+      reflection = Post.reflect_on_association(:comments_as_subject)
+      reflection.should_not be_nil
+      reflection.macro.should == :has_many
+      reflection.options[:class_name].should == "Comment"
+      reflection.options[:foreign_key].should == "subject"
+    end
+  end
+
+
+  context "with position" do
+    before(:each) do
+      create_tables(
+        "posts", {}, {},
+        "comments", {}, { :post_id => {}, :position => {} }
+      )
+      class Post < ActiveRecord::Base ; end
+      class Comment < ActiveRecord::Base ; end
+    end
+    it "should create ordered has_many association" do
+      reflection = Post.reflect_on_association(:comments)
+      reflection.should_not be_nil
+      reflection.macro.should == :has_many
+      reflection.options[:class_name].should == "Comment"
+      reflection.options[:foreign_key].should == "post_id"
+      reflection.options[:order].to_s.should == "position"
+    end
+  end
+
+  context "regarding parent-child relationships" do
+
+    let (:migration) {ActiveRecord::Migration}
+
+    before(:each) do
+      create_tables(
+        "nodes", {:foreign_keys => {:auto_index => false}}, { :parent_id => {} }
+      )
+    end
+
+    it "should use children as the inverse of parent" do
+      class Node < ActiveRecord::Base ; end
+      reflection = Node.reflect_on_association(:children)
+      reflection.should_not be_nil
+    end
+
+    it "should use child as the singular inverse of parent" do
+      migration.suppress_messages do
+        migration.add_index(:nodes, :parent_id, :unique => true)
+      end
+      class Node < ActiveRecord::Base ; end
+      reflection = Node.reflect_on_association(:child)
+      reflection.should_not be_nil
+    end
+  end
+
+
+  context "regarding concise names" do
+
+    def prefix_one
+      create_tables(
+        "posts", {}, {},
+        "post_comments", {}, { :post_id => {} }
+      )
+      Object.const_set(:Post, Class.new(ActiveRecord::Base))
+      Object.const_set(:PostComment, Class.new(ActiveRecord::Base))
+    end
+
+    def suffix_one
+      create_tables(
+        "posts", {}, {},
+        "comment_posts", {}, { :post_id => {} }
+      )
+      Object.const_set(:Post, Class.new(ActiveRecord::Base))
+      Object.const_set(:CommentPost, Class.new(ActiveRecord::Base))
+    end
+
+    def prefix_both
+      create_tables(
+        "blog_page_posts", {}, {},
+        "blog_page_comments", {}, { :blog_page_post_id => {} }
+      )
+      Object.const_set(:BlogPagePost, Class.new(ActiveRecord::Base))
+      Object.const_set(:BlogPageComment, Class.new(ActiveRecord::Base))
+    end
+
+    it "should use concise association name for one prefix" do
+      with_associations_config(:auto_create => true, :concise_names => true) do
+        prefix_one
+        reflection = Post.reflect_on_association(:comments)
+        reflection.should_not be_nil
+        reflection.macro.should == :has_many
+        reflection.options[:class_name].should == "PostComment"
+        reflection.options[:foreign_key].should == "post_id"
+      end
+    end
+
+    it "should use concise association name for one suffix" do
+      with_associations_config(:auto_create => true, :concise_names => true) do
+        suffix_one
+        reflection = Post.reflect_on_association(:comments)
+        reflection.should_not be_nil
+        reflection.macro.should == :has_many
+        reflection.options[:class_name].should == "CommentPost"
+        reflection.options[:foreign_key].should == "post_id"
+      end
+    end
+
+    it "should use concise association name for shared prefixes" do
+      with_associations_config(:auto_create => true, :concise_names => true) do
+        prefix_both
+        reflection = BlogPagePost.reflect_on_association(:comments)
+        reflection.should_not be_nil
+        reflection.macro.should == :has_many
+        reflection.options[:class_name].should == "BlogPageComment"
+        reflection.options[:foreign_key].should == "blog_page_post_id"
+      end
+    end
+
+    it "should use full names and not concise names when so configured" do
+      with_associations_config(:auto_create => true, :concise_names => false) do
+        prefix_one
+        reflection = Post.reflect_on_association(:post_comments)
+        reflection.should_not be_nil
+        reflection.macro.should == :has_many
+        reflection.options[:class_name].should == "PostComment"
+        reflection.options[:foreign_key].should == "post_id"
+        reflection = Post.reflect_on_association(:comments)
+        reflection.should be_nil
+      end
+    end
+
+    it "should use concise names and not full names when so configured" do
+      with_associations_config(:auto_create => true, :concise_names => true) do
+        prefix_one
+        reflection = Post.reflect_on_association(:comments)
+        reflection.should_not be_nil
+        reflection.macro.should == :has_many
+        reflection.options[:class_name].should == "PostComment"
+        reflection.options[:foreign_key].should == "post_id"
+        reflection = Post.reflect_on_association(:post_comments)
+        reflection.should be_nil
+      end
+    end
+
+
+  end
+
+  context "with joins table" do
+    before(:each) do
+      create_tables(
+        "posts", {}, {},
+        "tags", {}, {},
+        "posts_tags", {:id => false}, { :post_id => {}, :tag_id => {}}
+      )
+      class Post < ActiveRecord::Base ; end
+      class Tag < ActiveRecord::Base ; end
+    end
+    it "should create has_and_belongs_to_many association" do
+      reflection = Post.reflect_on_association(:tags)
+      reflection.should_not be_nil
+      reflection.macro.should == :has_and_belongs_to_many
+      reflection.options[:class_name].should == "Tag"
+      reflection.options[:join_table].should == "posts_tags"
+    end
+  end
+
+  context "regarding existing methods" do
+    before(:each) do
+      create_tables(
+        "types", {}, {},
+        "posts", {}, {:type_id => {}}
+      )
+    end
+    it "should define association normally if no existing method is defined" do
+      class Type < ActiveRecord::Base ; end
+      Type.reflect_on_association(:posts).should_not be_nil # sanity check for this context
+    end
+    it "should not define association over existing public method" do
+      class Type < ActiveRecord::Base
+        def posts
+          :existing
+        end
+      end
+      Type.reflect_on_association(:posts).should be_nil
+    end
+    it "should not define association over existing private method" do
+      class Type < ActiveRecord::Base
+        private
+        def posts
+          :existing
+        end
+      end
+      Type.reflect_on_association(:posts).should be_nil
+    end
+    it "should define association :type over (deprecated) kernel method" do
+      class Post < ActiveRecord::Base ; end
+      Post.reflect_on_association(:type).should_not be_nil
+    end
+    it "should not define association :type over model method" do
+      class Post < ActiveRecord::Base
+        def type
+          :existing
+        end
+      end
+      Post.reflect_on_association(:type).should be_nil
+    end
+  end
+
+  context "regarding relations" do
+    before(:each) do
+      create_tables(
+        "posts", {}, {},
+        "comments", {}, { :post_id => {} }
+      )
+      class Post < ActiveRecord::Base ; end
+      class Comment < ActiveRecord::Base ; end
+    end
+
+    it "should define associations before needed by relation" do
+      Post.joins(:comments).all
+      expect { Post.joins(:comments).all }.should_not raise_error
+
+    end
+
+  end
+
+  protected
+
+  def with_associations_auto_create(value, &block)
+    with_associations_config(:auto_create => value, &block)
+  end
+
+  def with_associations_config(opts, &block)
+    save = Hash[opts.keys.collect{|key| [key, SchemaAssociations.config.send(key)]}]
+    begin
+      SchemaAssociations.setup do |config|
+        config.update_attributes(opts)
+        yield
+      end
+    ensure
+      SchemaAssociations.config.update_attributes(save)
+    end
+  end
+
+  def create_tables(*table_defs)
+    ActiveRecord::Migration.suppress_messages do
+      ActiveRecord::Base.connection.tables.each do |table|
+        ActiveRecord::Migration.drop_table table
+      end
+      table_defs.each_slice(3) do |table_name, opts, columns_with_options|
+        ActiveRecord::Migration.create_table table_name, opts do |t|
+          columns_with_options.each_pair do |column, options|
+            t.integer column, options
+          end
+        end
+      end
+    end
+  end
+
+end

data/spec/connection.rb

@@ -0,0 +1,10 @@
+
+ActiveRecord::Base.configurations = {
+  'schema_associations' => {
+    :adapter => 'sqlite3',
+    :database => File.expand_path('schema_associations.sqlite3', File.dirname(__FILE__)),
+  }
+
+}
+
+ActiveRecord::Base.establish_connection 'schema_associations'

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+if RUBY_VERSION > "1.9"
+  require 'simplecov'
+  require 'simplecov-gem-adapter'
+  SimpleCov.start "gem"
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+
+require 'rspec'
+require 'active_record'
+require 'schema_associations'
+require 'logger'
+require 'connection'
+
+ActiveRecord::Base.logger = Logger.new(File.open("spec.log", "w"))
+
+Dir[File.dirname(__FILE__) + "/support/**/*.rb"].each {|f| require f}
+
+def remove_all_models
+    ObjectSpace.each_object(Class) do |c|
+      next unless c.ancestors.include? ActiveRecord::Base
+      next if c == ActiveRecord::Base
+      next if c.name.blank?
+      ActiveSupport::Dependencies.remove_constant c.name
+    end
+  end
+
+SimpleCov.command_name ActiveRecord::Base.connection.adapter_name if defined? SimpleCov