joinfix 0.1.0

data/test/has_many_test.rb

@@ -0,0 +1,97 @@
+require  File.dirname(__FILE__) + '/joinfix_test_helper'
+
+class HmMigration < ActiveRecord::Migration
+  def self.up
+	create_table :hm_parents do |t|
+		t.column :field, :string
+	end	
+	create_table :hm_children do |t|
+		t.column :field, :string
+		t.column :hm_parent_id, :integer
+		t.column :alt_id, :integer
+	end	
+	create_table :hm_joins do |t|
+		t.column :hm_parent_id, :integer
+		t.column :hm_child_id, :integer
+	end	
+	create_table :as_children do |t|
+		t.column :polymorphic_parent_id, :integer
+		t.column :polymorphic_parent_type, :string
+		t.column :field, :string
+	end
+  end
+
+  def self.down
+	drop_table :hm_parents
+	drop_table :hm_children
+	drop_table :hm_joins
+	drop_table :as_children
+  end
+end
+
+class HmParent < ActiveRecord::Base
+	has_many :hm_children
+	has_many :children, 
+		:foreign_key => "alt_id",
+		:class_name => "HmChild"
+		
+	has_many :hm_joins
+	has_many :join_children, 
+		:through => :hm_joins,
+		:source => :hm_child
+		
+	has_many :through_children, 
+		:through => :hm_joins,
+		:source => :hm_child
+		
+	has_many :as_children, 
+		:as => :polymorphic_parent
+end
+
+class HmChild < ActiveRecord::Base
+end
+
+class HmJoin < ActiveRecord::Base
+	belongs_to :hm_child
+end
+
+class AsChild < ActiveRecord::Base
+	belongs_to :polymorphic_parent, :polymorphic => true
+end
+
+class HasManyTest < Test::Unit::TestCase
+	fixtures :hm_parents, :hm_children, :hm_joins, :as_children
+	
+	def setup
+	end
+	
+	def teardown
+	end
+	
+	def test_has_many
+		database_test(HmMigration) do 
+			entry = hm_parents(:without_children)
+			assert_equal "without_children", entry.field
+			assert entry.hm_children.empty?
+			assert entry.children.empty?
+			assert entry.join_children.empty?
+			assert entry.as_children.empty?
+			
+			entry = hm_parents(:with_hm_children)
+			assert_equal "with_hm_children", entry.field
+			assert_equal ["1","2"], entry.hm_children.collect {|e| e.field}.sort
+			
+			entry = hm_parents(:with_children)
+			assert_equal "with_children", entry.field
+			assert_equal ["3","4"], entry.children.collect {|e| e.field}.sort
+		
+			entry = hm_parents(:with_through_children)
+			assert_equal "with_through_children", entry.field
+			assert_equal ["5","6"], entry.join_children.collect {|e| e.field}.sort
+			
+			entry = hm_parents(:with_as_children)
+			assert_equal "with_as_children", entry.field
+			assert_equal ["7","8"], entry.as_children.collect {|e| e.field}.sort
+		end
+	end
+end

data/test/has_one_test.rb

@@ -0,0 +1,56 @@
+require  File.dirname(__FILE__) + '/joinfix_test_helper'
+
+class HoMigration < ActiveRecord::Migration
+  def self.up
+	create_table :ho_parents do |t|
+		t.column :field, :string
+	end	
+	create_table :ho_children do |t|
+		t.column :field, :string
+		t.column :ho_parent_id, :integer
+		t.column :alt_id, :integer
+	end	
+  end
+
+  def self.down
+	drop_table :ho_parents
+	drop_table :ho_children
+  end
+end
+
+class HoParent < ActiveRecord::Base
+	has_one :ho_child
+	has_one :child, 
+		:foreign_key => "alt_id",
+		:class_name => "HoChild"
+end
+
+class HoChild < ActiveRecord::Base
+end
+
+class HasOneTest < Test::Unit::TestCase
+	fixtures :ho_parents, :ho_children
+	
+	def setup
+	end
+	
+	def teardown
+	end
+	
+	def test_has_one
+		database_test(HoMigration) do 
+			entry = ho_parents(:without_child)
+			assert_equal "without_child", entry.field
+			assert_nil entry.ho_child
+			assert_nil entry.child
+			
+			entry = ho_parents(:with_ho_child)
+			assert_equal "with_ho_child", entry.field
+			assert_equal "1", entry.ho_child.field
+			
+			entry = ho_parents(:with_child)
+			assert_equal "with_child", entry.field
+			assert_equal "2", entry.child.field
+		end
+	end
+end

data/test/joinfix_test.rb

@@ -0,0 +1,287 @@
+require  File.dirname(__FILE__) + '/joinfix_test_helper'
+require 'joinfix'
+
+class NoJoinFixMigration < ActiveRecord::Migration
+  def self.up
+	create_table :no_join_fixes do |t|
+		t.column :field, :string
+	end	
+	create_table :omap_no_join_fixes do |t|
+		t.column :field, :string
+	end	
+  end
+
+  def self.down
+	drop_table :no_join_fixes
+	drop_table :omap_no_join_fixes
+  end
+end
+
+class NoJoinFix < ActiveRecord::Base
+end
+
+class OmapNoJoinFix < ActiveRecord::Base
+end
+
+class JoinFixTest < Test::Unit::TestCase
+	fixtures :no_join_fixes, :omap_no_join_fixes
+	
+	attr_reader :joinfix, :parent, :child
+	def setup
+		@joinfix = JoinFix.new("joinfix")
+		@parent = JoinFix.new("parent_entry", :name => "parent_name")
+		@child =  JoinFix.new("child_entry", :name => "child_name")
+	end
+	
+	def teardown
+	end
+	
+	#
+	# compatability tests
+	#
+	
+	def test_fixtures_without_templates_are_unaffected
+		database_test(NoJoinFixMigration) do |connection|		
+			assert_equal "1", no_join_fixes(:first).field
+			assert_equal "2", no_join_fixes(:second).field
+		end
+	end
+	
+	def test_omap_fixtures_without_templates_are_unaffected
+		database_test(NoJoinFixMigration) do |connection|		
+			assert_equal 1, omap_no_join_fixes(:first).id
+			assert_equal 2, omap_no_join_fixes(:second).id
+		end
+	end
+
+	#
+	# preserved keys test
+	#
+	
+	def test_id_keys_are_preserved
+		[:id, :preserved_id].each do |key|
+			assert JoinFix.preserves?(key)
+			assert JoinFix.preserves?(key.to_s)
+		end
+		
+		[:not_preserved, :pid, "_id"].each do |key|
+			assert !JoinFix.preserves?(key)
+			assert !JoinFix.preserves?(key.to_s)
+		end
+	end
+	
+	#
+	# join tests
+	#
+	
+	# Note that for all of these tests, the envisioned fixture looks like:
+	# parent_entry:
+	#  name: parent_name
+	#  association:
+	#    child_entry:
+	#      name: child_name
+	#
+	# This template produces the parent and child entries.  The configurations may be derived from
+	# reflection on the given association for the parent table ActiveRecord::Base class.
+	#
+	
+	# join_belongs_to  tests
+	def test_join_belongs_to
+		assert_nil parent.join_belongs_to(child, :foreign_key => "foreign_key", :child_table => "child_table")
+		
+		assert_equal({:name => "parent_name", ["foreign_key", "child_table"] => "child_entry"}, parent)
+		assert_equal({:name => "child_name"}, child)
+	end
+
+	def test_join_belongs_to_when_polymorphic
+		assert_nil parent.join_belongs_to(child, 
+			:polymorphic => true, 
+			:associable => "associable", 
+			:foreign_key => "associable", 
+			:child_table => "child_table", 
+			:child_class => "ChildTable" )
+		
+		assert_equal({
+			:name => "parent_name", 
+			["associable", "child_table"] => "child_entry",
+			"associable_type" => "ChildTable"}, parent)
+		assert_equal({:name => "child_name"}, child)
+	end
+	
+	def test_join_belongs_to_validates_inclusion_of_required_configurations
+		assert_raise(ArgumentError) { joinfix.join_belongs_to(nil, {}) }
+		assert_raise(ArgumentError) { joinfix.join_belongs_to(nil, :polymorphic => true) }
+		assert_raise(ArgumentError) { joinfix.join_belongs_to(nil, :child_table => "child_table") }
+	end
+	
+	# join_has_one  tests
+	def test_join_has_one
+		assert_nil parent.join_has_one(child, 
+			:foreign_key => "foreign_key", 
+			:parent_table => "parent_table")
+		
+		assert_equal({:name => "parent_name"}, parent)
+		assert_equal({:name => "child_name", ["foreign_key", "parent_table"] => "parent_entry"}, child)
+	end
+	
+	def test_join_has_one_validates_inclusion_of_required_configurations
+		assert_raise(ArgumentError) { joinfix.join_has_one(nil, {}) }
+		assert_raise(ArgumentError) { joinfix.join_has_one(nil, :foreign_key => "foreign_key") }
+		assert_raise(ArgumentError) { joinfix.join_has_one(nil, :parent_table => "parent_table") }
+	end
+	
+	# join_has_and_belongs_to_many tests
+	def test_join_has_and_belongs_to_many	
+		join = parent.join_has_and_belongs_to_many(child, 
+				:foreign_key => "foreign_key", 
+				:parent_table => "parent_table",
+				:association_foreign_key => "association_foreign_key",
+				:child_table => "child_table")
+		
+		assert_equal({:name => "parent_name"}, parent)
+		assert_equal({:name => "child_name"}, child)
+		assert_equal({["foreign_key", "parent_table"] => "parent_entry", ["association_foreign_key", "child_table"] => "child_entry"}, join)
+	end
+	
+	def test_join_has_and_belongs_to_many_with_attributes
+		attributes = {:some_attribute => "attribute"}
+		
+		join = parent.join_has_and_belongs_to_many(child, 
+				:foreign_key => "foreign_key", 
+				:parent_table => "parent_table",
+				:association_foreign_key => "association_foreign_key", 
+				:child_table => "child_table",
+				:attributes => attributes)
+		
+		assert_equal({:name => "parent_name"}, parent)
+		assert_equal({:name => "child_name"}, child)
+		assert_equal(attributes.merge( ["foreign_key", "parent_table"] => "parent_entry", ["association_foreign_key", "child_table"] => "child_entry" ), join)
+	end
+	
+	def test_join_has_and_belongs_to_many_validates_inclusion_of_required_configurations
+		assert_raise(ArgumentError) { joinfix.join_has_and_belongs_to_many(nil, {}) }
+		assert_raise(ArgumentError) { joinfix.join_has_and_belongs_to_many(nil, :foreign_key => "foreign_key") }
+		assert_raise(ArgumentError) { joinfix.join_has_and_belongs_to_many(nil, :association_foreign_key => "parent_table") }
+	end
+	
+	# join_has_many test
+	def test_join_has_many	
+		assert_nil parent.join_has_many(child, 
+			:foreign_key => "foreign_key", 
+			:parent_table => "parent_table")
+		
+		assert_equal({:name => "parent_name"}, parent)
+		assert_equal({:name => "child_name", ["foreign_key", "parent_table"] => "parent_entry"}, child)
+	end
+	
+	def test_join_has_many_as
+		assert_nil parent.join_has_many(child, 
+			:as => "associable", 
+			:foreign_key => "associable", 
+			:parent_table => "parent_table", 
+			:parent_class => "ParentTable")
+		
+		assert_equal({:name => "parent_name"}, parent)
+		assert_equal({
+			:name => "child_name", 
+			["associable", "parent_table"] => "parent_entry",
+			"associable_type" => "ParentTable"}, child)
+	end
+	
+	def test_join_has_many_through
+		join = parent.join_has_many(child, 
+				:through => "some_join_table",
+				:foreign_key => "foreign_key", 
+				:parent_table => "parent_table",
+				:association_foreign_key => "association_foreign_key", 
+				:child_table => "child_table")
+		
+		assert_equal({:name => "parent_name"}, parent)
+		assert_equal({:name => "child_name"}, child)
+		assert_equal({["foreign_key", "parent_table"] => "parent_entry", ["association_foreign_key", "child_table"] => "child_entry"}, join)
+	end
+	
+	def test_join_has_many_through_with_attributes
+		attributes = {:some_attribute => "attribute"}
+		
+		join = parent.join_has_many(child, 
+				:through => "some_join_table",
+				:foreign_key => "foreign_key", 
+				:parent_table => "parent_table",
+				:association_foreign_key => "association_foreign_key", 
+				:child_table => "child_table",
+				:attributes => attributes)
+		
+		assert_equal({:name => "parent_name"}, parent)
+		assert_equal({:name => "child_name"}, child)
+		assert_equal(attributes.merge(["foreign_key", "parent_table"] => "parent_entry", ["association_foreign_key", "child_table"] => "child_entry"), join)
+	end
+	
+	#
+	# test extract_if
+	#
+	
+	def test_extract_if_with_no_inputs
+		joinfix = JoinFix.new("extraction", :do_not_extract=> 'value')
+		
+		extracted = joinfix.extract_if 
+		
+		# in this case there are no keys, so no pairs are extracted
+		assert_equal({}, extracted)
+		assert_equal({:do_not_extract => 'value'}, joinfix)
+	end
+	
+	def test_extract_if_using_allowed_keys
+		joinfix = JoinFix.new("extraction", :do_not_extract => 'value', :extract => 'value')
+		
+		extracted = joinfix.extract_if :extract
+		
+		assert_equal({:extract=> 'value'}, extracted)
+		assert_equal({:do_not_extract => 'value'}, joinfix)
+	end
+	
+	def test_extract_if_using_block
+		joinfix = JoinFix.new("extraction", :do_not_extract => 'value', :extract => 'value')
+		
+		extracted = joinfix.extract_if do |key, value|
+			key == :extract
+		end
+		
+		assert_equal({:extract => 'value'}, extracted)
+		assert_equal({:do_not_extract => 'value'}, joinfix)
+	end
+	
+	#
+	#  test extract_unless
+	#
+	
+	def test_extract_unless_with_no_inputs
+		joinfix = JoinFix.new("extraction", :extract=> 'value')
+		
+		extracted = joinfix.extract_unless
+		
+		# in this case there are no allowed keys, so all pairs are extracted
+		assert_equal({:extract => 'value'}, extracted)
+		assert_equal({}, joinfix)
+	end
+	
+	def test_extract_unless_using_allowed_keys
+		joinfix = JoinFix.new("extraction", :do_not_extract => 'value', :extract => 'value')
+		
+		extracted = joinfix.extract_unless :do_not_extract
+		
+		assert_equal({:extract=> 'value'}, extracted)
+		assert_equal({:do_not_extract => 'value'}, joinfix)
+	end
+	
+	def test_extract_unless_using_block
+		joinfix = JoinFix.new("extraction", :do_not_extract => 'value', :extract => 'value')
+		
+		extracted = joinfix.extract_unless do |key, value|
+			key == :do_not_extract
+		end
+		
+		assert_equal({:extract => 'value'}, extracted)
+		assert_equal({:do_not_extract => 'value'}, joinfix)
+	end
+end

data/test/joinfix_test_helper.rb

@@ -0,0 +1,54 @@
+require 'gemdev'
+require 'test/unit/subsets'
+require 'active_record'
+require 'active_record/fixtures'
+require 'joinfix'
+require 'tempfile'
+
+# Try to extablish a connection to the configured database
+# if this doesn't work, then none of the database_tests will run
+config = YAML.load_file(File.dirname(__FILE__) + '/config.yml').symbolize_keys
+ActiveRecord::Base.establish_connection(config)
+begin
+	ActiveRecord::Base.connection
+	
+	# Not sure what these configurations should point to, but 
+	# setup_with_fixtures requires that configurations is not empty
+	# in order to run, so...
+	ActiveRecord::Base.configurations["joinfix"] = config
+rescue
+	puts "ActiveRecord connection could not be established using:"
+	pp config
+end
+
+class Test::Unit::TestCase
+	# With the setup in fixtures, I had to override setup and teardown so
+	# that by default, the setup_with_fixtures method is not called
+	#
+	# I do want to call setup_with_fixtures, but only in the context
+	# of database test
+	
+	def setup
+	end
+	
+	def teardown
+	end
+	
+	def database_test(*migrations, &block)
+		switch_test( ActiveRecord::Base.connected? ) do 
+			ActiveRecord::Migration.verbose = false
+			
+			begin
+				migrations.each {|migration| migration.up}
+				setup_with_fixtures
+				yield(ActiveRecord::Base.connection)
+			ensure
+				teardown_with_fixtures
+				migrations.each {|migration| migration.down}
+			end
+		end
+	end
+end
+
+# set the fixture path
+Test::Unit::TestCase.fixture_path = File.dirname(__FILE__) + "/fixtures"

data/test/joinfix_test_suite.rb

@@ -0,0 +1,10 @@
+$:.unshift File.join(File.dirname(__FILE__), '../lib')
+
+puts %{
+   NOTE!  The joinfix tests are not run through this test suite
+   because they require a database to connect to.  See TEST_README
+   for details and instructions on running the joinfix tests.
+}
+#
+#ENV["ALL"] = 'true'
+#Dir.glob("./**/*_test.rb").each {|test| require test}

data/test/nested_test.rb

@@ -0,0 +1,70 @@
+require  File.dirname(__FILE__) + '/joinfix_test_helper'
+
+class NestedMigration < ActiveRecord::Migration
+  def self.up
+	create_table :nested_parents do |t|
+		t.column :field, :string
+		t.column :inner_child_id, :integer
+	end	
+	create_table :nested_children do |t|
+		t.column :field, :string
+		t.column :nested_parent_id, :integer
+	end	
+	create_table :inner_children do |t|
+		t.column :field, :string
+		t.column :nested_child_id, :integer
+	end	
+  end
+
+  def self.down
+	drop_table :nested_parents
+	drop_table :nested_children
+	drop_table :inner_children
+  end
+end
+
+class NestedParent < ActiveRecord::Base
+	belongs_to :inner_child
+	has_many :nested_children
+end
+
+class NestedChild < ActiveRecord::Base
+	belongs_to :nested_parent
+	has_many :inner_children
+end
+
+class InnerChild < ActiveRecord::Base
+	belongs_to :nested_child
+	has_many :nested_parents
+end
+
+class NestedTest < Test::Unit::TestCase
+	fixtures :nested_parents, :nested_children, :inner_children
+	
+	def setup
+	end
+	
+	def teardown
+	end
+	
+	def test_nested_fixtures
+		database_test(NestedMigration) do 
+			parent_one= nested_parents(:parent_one)
+			parent_two = nested_parents(:parent_two)
+			parent_three = nested_parents(:parent_three)
+			parent_four = nested_parents(:parent_four)
+			
+			query_result = NestedChild.find_by_field(1).nested_parent
+			assert_equal parent_one, query_result
+			
+			query_result = NestedParent.find_by_field(1).nested_children.first.inner_children.first.nested_parents
+			assert_equal [parent_two, parent_three], query_result
+			
+			query_result = NestedParent.find_by_field(1).inner_child.nested_child.nested_parent
+			assert_equal parent_two, query_result
+			
+			query_result = InnerChild.find_by_field(3).nested_parents.first
+			assert_equal parent_four, query_result
+		end
+	end
+end