composite_primary_keys 11.0.0.rc1 → 11.0.0.rc2

data/test/test_dumpable.rb

@@ -1,15 +1,15 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestDumpable < ActiveSupport::TestCase
-  fixtures :articles, :readings, :users
-
-  def test_marshal_with_simple_preload
-    articles = Article.preload(:readings).where(id: 1).to_a
-    assert_equal(Marshal.load(Marshal.dump(articles)), articles)
-  end
-
-  def test_marshal_with_comples_preload
-    articles = Article.preload({ readings: :user }).where(id: 1).to_a
-    assert_equal(Marshal.load(Marshal.dump(articles)), articles)
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class TestDumpable < ActiveSupport::TestCase
+  fixtures :articles, :readings, :users
+
+  def test_marshal_with_simple_preload
+    articles = Article.preload(:readings).where(id: 1).to_a
+    assert_equal(Marshal.load(Marshal.dump(articles)), articles)
+  end
+
+  def test_marshal_with_comples_preload
+    articles = Article.preload({ readings: :user }).where(id: 1).to_a
+    assert_equal(Marshal.load(Marshal.dump(articles)), articles)
+  end
+end

data/test/test_enum.rb

@@ -1,21 +1,21 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestEnum < ActiveSupport::TestCase
-  fixtures :comments
-
-  def test_enum_was
-    comment = Comment.first
-    assert_nil comment.shown
-    assert_equal({}, comment.changed_attributes)
-    comment.shown = :true
-    assert_equal({ "shown" => nil }, comment.changed_attributes)
-    assert_equal 'true', comment.shown
-    assert_nil comment.shown_was
-
-    comment.save
-
-    comment.shown = :false
-    assert_equal 'false', comment.shown
-    assert_equal 'true', comment.shown_was
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class TestEnum < ActiveSupport::TestCase
+  fixtures :comments
+
+  def test_enum_was
+    comment = Comment.first
+    assert_nil comment.shown
+    assert_equal({}, comment.changed_attributes)
+    comment.shown = :true
+    assert_equal({ "shown" => nil }, comment.changed_attributes)
+    assert_equal 'true', comment.shown
+    assert_nil comment.shown_was
+
+    comment.save
+
+    comment.shown = :false
+    assert_equal 'false', comment.shown
+    assert_equal 'true', comment.shown_was
+  end
+end

data/test/test_equal.rb

@@ -1,26 +1,26 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestEqual < ActiveSupport::TestCase
-  fixtures :capitols
-
-  def test_new
-    assert_equal(Capitol.new, Capitol.new)
-  end
-
-  def test_same_new
-    it = Capitol.new
-    assert_equal(it, it)
-  end
-
-  def test_same
-    first = Capitol.find(['Canada', 'Ottawa'])
-    second = Capitol.find(['Canada', 'Ottawa'])
-    assert_equal(first, second)
-  end
-
-  def test_different
-    first = Capitol.find(['Mexico', 'Mexico City'])
-    second = Capitol.find(['Canada', 'Ottawa'])
-    assert_not_equal(first, second)
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class TestEqual < ActiveSupport::TestCase
+  fixtures :capitols
+
+  def test_new
+    assert_equal(Capitol.new, Capitol.new)
+  end
+
+  def test_same_new
+    it = Capitol.new
+    assert_equal(it, it)
+  end
+
+  def test_same
+    first = Capitol.find(['Canada', 'Ottawa'])
+    second = Capitol.find(['Canada', 'Ottawa'])
+    assert_equal(first, second)
+  end
+
+  def test_different
+    first = Capitol.find(['Mexico', 'Mexico City'])
+    second = Capitol.find(['Canada', 'Ottawa'])
+    assert_not_equal(first, second)
+  end
+end

data/test/test_find.rb

@@ -1,137 +1,137 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-# Testing the find action on composite ActiveRecords with two primary keys
-class TestFind < ActiveSupport::TestCase
-  fixtures :capitols, :departments, :reference_types, :reference_codes,
-    :suburbs, :employees
-
-  def test_find_first
-    ref_code = ReferenceCode.order('reference_type_id, reference_code').first
-    assert_kind_of(ReferenceCode, ref_code)
-    assert_equal([1,1], ref_code.id)
-  end
-
-  def test_find_last
-    ref_code = ReferenceCode.order('reference_type_id, reference_code').last
-    assert_kind_of(ReferenceCode, ref_code)
-    assert_equal([2,2], ref_code.id)
-  end
-
-  def test_find_one
-    ref_code = ReferenceCode.find([1,3])
-    assert_not_nil(ref_code)
-    assert_equal([1,3], ref_code.id)
-  end
-
-  def test_find_some
-    ref_codes = ReferenceCode.find([1,3], [2,1])
-    assert_kind_of(Array, ref_codes)
-    assert_equal(2, ref_codes.length)
-
-    ref_code = ref_codes[0]
-    assert_equal([1,3], ref_code.id)
-
-    ref_code = ref_codes[1]
-    assert_equal([2,1], ref_code.id)
-  end
-
-  def test_find_with_strings_as_composite_keys
-    capitol = Capitol.find(['The Netherlands', 'Amsterdam'])
-    assert_kind_of(Capitol, capitol)
-    assert_equal(['The Netherlands', 'Amsterdam'], capitol.id)
-  end
-
-  def test_find_each
-    room_assignments = []
-    RoomAssignment.find_each(:batch_size => 2) do |assignment|
-      room_assignments << assignment
-    end
-
-    assert_equal(RoomAssignment.count, room_assignments.uniq.length)
-  end
-
-  def test_find_each_with_scope
-    scoped_departments = Department.where("department_id <> 3")
-    scoped_departments.find_each(:batch_size => 2) do |department|
-      assert department.id != 3
-    end
-  end
-
-  def test_not_found
-    error = assert_raise(::ActiveRecord::RecordNotFound) do
-      ReferenceCode.find(['999', '999'])
-    end
-
-    expected = "Couldn't find all ReferenceCodes with 'reference_type_id,reference_code': (999, 999) (found 0 results, but was looking for 1)."
-    assert_equal(with_quoted_identifiers(expected), error.message)
-  end
-
-  def test_find_last_suburb
-    suburb = Suburb.last
-    assert_equal([2,1], suburb.id)
-  end
-
-  def test_find_last_suburb_with_order
-    # Rails actually changes city_id DESC to city_id ASC
-    suburb = Suburb.order('suburbs.city_id DESC').last
-    assert_equal([1,1], suburb.id)
-  end
-
-  def test_find_in_batches
-    Department.find_in_batches do |batch|
-      assert_equal(Department.count, batch.size)
-    end
-  end
-
-  def test_in_batches_of_1
-    num_found = 0
-    Department.in_batches(of: 1) do |batch|
-      batch.each do |dept|
-        num_found += 1
-      end
-    end
-    assert_equal(Department.count, num_found)
-  end
-
-  def test_find_by_one_association
-    department = departments(:engineering)
-    employees = Employee.where(:department => department)
-    assert_equal(2, employees.to_a.count)
-  end
-
-  def test_find_by_all_associations
-    departments = Department.all
-    employees = Employee.where(:department => departments)
-    assert_equal(4, employees.to_a.count)
-  end
-
-  def test_expand_all
-    departments = Department.all
-    employees = Employee.where(:department => departments)
-    assert_equal(4, employees.count)
-  end
-
-  def test_find_one_with_params_id
-    params_id = ReferenceCode.find([1,3]).to_param
-    assert_equal params_id, "1,3"
-
-    ref_code = ReferenceCode.find(params_id)
-    assert_not_nil(ref_code)
-    assert_equal([1,3], ref_code.id)
-  end
-
-  def test_find_some_with_array_of_params_id
-    params_ids = ReferenceCode.find([1,3], [2,1]).map(&:to_param)
-    assert_equal ["1,3", "2,1"], params_ids
-
-    ref_codes = ReferenceCode.find(params_ids)
-    assert_kind_of(Array, ref_codes)
-    assert_equal(2, ref_codes.length)
-
-    ref_code = ref_codes[0]
-    assert_equal([1,3], ref_code.id)
-
-    ref_code = ref_codes[1]
-    assert_equal([2,1], ref_code.id)
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+# Testing the find action on composite ActiveRecords with two primary keys
+class TestFind < ActiveSupport::TestCase
+  fixtures :capitols, :departments, :reference_types, :reference_codes,
+    :suburbs, :employees
+
+  def test_find_first
+    ref_code = ReferenceCode.order('reference_type_id, reference_code').first
+    assert_kind_of(ReferenceCode, ref_code)
+    assert_equal([1,1], ref_code.id)
+  end
+
+  def test_find_last
+    ref_code = ReferenceCode.order('reference_type_id, reference_code').last
+    assert_kind_of(ReferenceCode, ref_code)
+    assert_equal([2,2], ref_code.id)
+  end
+
+  def test_find_one
+    ref_code = ReferenceCode.find([1,3])
+    assert_not_nil(ref_code)
+    assert_equal([1,3], ref_code.id)
+  end
+
+  def test_find_some
+    ref_codes = ReferenceCode.find([1,3], [2,1])
+    assert_kind_of(Array, ref_codes)
+    assert_equal(2, ref_codes.length)
+
+    ref_code = ref_codes[0]
+    assert_equal([1,3], ref_code.id)
+
+    ref_code = ref_codes[1]
+    assert_equal([2,1], ref_code.id)
+  end
+
+  def test_find_with_strings_as_composite_keys
+    capitol = Capitol.find(['The Netherlands', 'Amsterdam'])
+    assert_kind_of(Capitol, capitol)
+    assert_equal(['The Netherlands', 'Amsterdam'], capitol.id)
+  end
+
+  def test_find_each
+    room_assignments = []
+    RoomAssignment.find_each(:batch_size => 2) do |assignment|
+      room_assignments << assignment
+    end
+
+    assert_equal(RoomAssignment.count, room_assignments.uniq.length)
+  end
+
+  def test_find_each_with_scope
+    scoped_departments = Department.where("department_id <> 3")
+    scoped_departments.find_each(:batch_size => 2) do |department|
+      assert department.id != 3
+    end
+  end
+
+  def test_not_found
+    error = assert_raise(::ActiveRecord::RecordNotFound) do
+      ReferenceCode.find(['999', '999'])
+    end
+
+    expected = "Couldn't find all ReferenceCodes with 'reference_type_id,reference_code': (999, 999) (found 0 results, but was looking for 1)."
+    assert_equal(with_quoted_identifiers(expected), error.message)
+  end
+
+  def test_find_last_suburb
+    suburb = Suburb.last
+    assert_equal([2,1], suburb.id)
+  end
+
+  def test_find_last_suburb_with_order
+    # Rails actually changes city_id DESC to city_id ASC
+    suburb = Suburb.order('suburbs.city_id DESC').last
+    assert_equal([1,1], suburb.id)
+  end
+
+  def test_find_in_batches
+    Department.find_in_batches do |batch|
+      assert_equal(Department.count, batch.size)
+    end
+  end
+
+  def test_in_batches_of_1
+    num_found = 0
+    Department.in_batches(of: 1) do |batch|
+      batch.each do |dept|
+        num_found += 1
+      end
+    end
+    assert_equal(Department.count, num_found)
+  end
+
+  def test_find_by_one_association
+    department = departments(:engineering)
+    employees = Employee.where(:department => department)
+    assert_equal(2, employees.to_a.count)
+  end
+
+  def test_find_by_all_associations
+    departments = Department.all
+    employees = Employee.where(:department => departments)
+    assert_equal(4, employees.to_a.count)
+  end
+
+  def test_expand_all
+    departments = Department.all
+    employees = Employee.where(:department => departments)
+    assert_equal(4, employees.count)
+  end
+
+  def test_find_one_with_params_id
+    params_id = ReferenceCode.find([1,3]).to_param
+    assert_equal params_id, "1,3"
+
+    ref_code = ReferenceCode.find(params_id)
+    assert_not_nil(ref_code)
+    assert_equal([1,3], ref_code.id)
+  end
+
+  def test_find_some_with_array_of_params_id
+    params_ids = ReferenceCode.find([1,3], [2,1]).map(&:to_param)
+    assert_equal ["1,3", "2,1"], params_ids
+
+    ref_codes = ReferenceCode.find(params_ids)
+    assert_kind_of(Array, ref_codes)
+    assert_equal(2, ref_codes.length)
+
+    ref_code = ref_codes[0]
+    assert_equal([1,3], ref_code.id)
+
+    ref_code = ref_codes[1]
+    assert_equal([2,1], ref_code.id)
+  end
+end

data/test/test_habtm.rb

@@ -1,141 +1,141 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestHabtm < ActiveSupport::TestCase
-  fixtures :suburbs, :restaurants, :restaurants_suburbs, :products, :groups, :employees
-
-  def test_no_cpk
-    # This test makes sure we don't break anything in standard rails by using CPK
-    groups = Group.all
-
-    # First test records
-    employee = Employee.first
-    assert_equal(0, employee.groups.length)
-    employee.groups = groups
-    employee.reload
-    assert_equal(groups, employee.groups)
-  end
-
-  def test_no_cpk_ids
-    # This test makes sure we don't break anything in standard rails by using CPK
-    groups = Group.all
-
-    employee = Employee.last
-    assert_equal(0, employee.groups.length)
-    employee.group_ids = groups.map {|group| group.id}
-    employee.group_ids = [groups.first.id]
-    employee.reload
-    assert_equal([groups.first], employee.groups)
-  end
-
-  def test_has_and_belongs_to_many
-    @restaurant = Restaurant.find([1,1])
-    assert_equal 2, @restaurant.suburbs.size
-
-    @restaurant = Restaurant.includes(:suburbs).find([1,1])
-    assert_equal 2, @restaurant.suburbs.size
-  end
-
-  def test_include_cpk_both_sides
-    # assuming the association was set up in the fixtures
-    # file restaurants_suburbs.yml
-    mcdonalds = restaurants(:mcdonalds)
-    # check positive
-    suburb = mcdonalds.suburbs[0]
-    assert mcdonalds.suburbs.include?(suburb)
-    # check negative
-    suburb_with_no_mcdonalds = suburbs(:no_mcdonalds)
-    assert !mcdonalds.suburbs.include?(suburb_with_no_mcdonalds)
-  end
-
-  def test_include_cpk_owner_side_only
-    subway = restaurants(:subway_one)
-    product = products(:first_product)
-    subway.products << product
-
-    # reload
-    # test positive
-    subway = restaurants(:subway_one)
-    assert subway.products.include?(product)
-
-    # test negative
-    product_two = products(:second_product)
-    assert !subway.products.include?(product_two)
-  end
-
-  def test_include_cpk_association_side_only
-    product = products(:first_product)
-    subway = restaurants(:subway_one)
-    product.restaurants << subway
-
-    # reload
-    # test positive
-    product = products(:first_product)
-    assert product.restaurants.include?(subway)
-
-    # test negative
-    mcdonalds = restaurants(:mcdonalds)
-    assert !product.restaurants.include?(mcdonalds)
-  end
-
-  def test_habtm_clear_cpk_both_sides
-    @restaurant = restaurants(:mcdonalds)
-    assert_equal 2, @restaurant.suburbs.size
-    @restaurant.suburbs.clear
-    assert_equal 0, @restaurant.suburbs.size
-  end
-
-  def test_habtm_clear_cpk_owner_side_only
-    subway = restaurants(:subway_one)
-    assert_equal 0, subway.products.size, 'Baseline'
-
-    first_product = products(:first_product)
-    second_product = products(:second_product)
-    subway.products << first_product << second_product
-    assert_equal 2, subway.products.size
-    subway.products.clear
-    # reload to force reload of associations
-    subway = restaurants(:subway_one)
-    assert_equal 0, subway.products.size
-  end
-
-  def test_habtm_clear_cpk_association_side_only
-    product = products(:first_product)
-    assert_equal 0, product.restaurants.size, 'Baseline'
-
-    subway_one = restaurants(:subway_one)
-    subway_two = restaurants(:subway_two)
-    product.restaurants << subway_one << subway_two
-    assert_equal 2, product.restaurants.size
-    product.restaurants.clear
-    # reload to force reload of associations
-    product = products(:first_product)
-    assert_equal 0, product.restaurants.size
-  end
-
-  # tests case reported in issue #39 where a bug resulted in
-  # deletion of incorrect join table records because the owner's id
-  # was assumed to be an array and is not in this case
-  # and evaluates to a useable but incorrect value
-  def test_habtm_clear_cpk_association_side_only_deletes_only_correct_records
-    product_one = Product.find(1)
-    product_three = Product.find(3)
-    subway_one = restaurants(:subway_one)
-    subway_two = restaurants(:subway_two)
-    product_one.restaurants << subway_one << subway_two
-    product_three.restaurants << subway_one << subway_two
-    assert_equal 2, product_one.restaurants.size
-    assert_equal 2, product_three.restaurants.size
-
-    # if product_three's id is incorrectly assumed to be
-    # an array it will be evaluated as 3[0], which is 1, which would
-    # delete product_one's associations rather than product_three's
-    product_three.restaurants.clear
-
-    # reload to force reload of associations
-    product_one = Product.find(1)
-    assert_equal 2, product_one.restaurants.size
-
-    product_three = Product.find(3)
-    assert_equal 0, product_three.restaurants.size
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class TestHabtm < ActiveSupport::TestCase
+  fixtures :suburbs, :restaurants, :restaurants_suburbs, :products, :groups, :employees
+
+  def test_no_cpk
+    # This test makes sure we don't break anything in standard rails by using CPK
+    groups = Group.all
+
+    # First test records
+    employee = Employee.first
+    assert_equal(0, employee.groups.length)
+    employee.groups = groups
+    employee.reload
+    assert_equal(groups, employee.groups)
+  end
+
+  def test_no_cpk_ids
+    # This test makes sure we don't break anything in standard rails by using CPK
+    groups = Group.all
+
+    employee = Employee.last
+    assert_equal(0, employee.groups.length)
+    employee.group_ids = groups.map {|group| group.id}
+    employee.group_ids = [groups.first.id]
+    employee.reload
+    assert_equal([groups.first], employee.groups)
+  end
+
+  def test_has_and_belongs_to_many
+    @restaurant = Restaurant.find([1,1])
+    assert_equal 2, @restaurant.suburbs.size
+
+    @restaurant = Restaurant.includes(:suburbs).find([1,1])
+    assert_equal 2, @restaurant.suburbs.size
+  end
+
+  def test_include_cpk_both_sides
+    # assuming the association was set up in the fixtures
+    # file restaurants_suburbs.yml
+    mcdonalds = restaurants(:mcdonalds)
+    # check positive
+    suburb = mcdonalds.suburbs[0]
+    assert mcdonalds.suburbs.include?(suburb)
+    # check negative
+    suburb_with_no_mcdonalds = suburbs(:no_mcdonalds)
+    assert !mcdonalds.suburbs.include?(suburb_with_no_mcdonalds)
+  end
+
+  def test_include_cpk_owner_side_only
+    subway = restaurants(:subway_one)
+    product = products(:first_product)
+    subway.products << product
+
+    # reload
+    # test positive
+    subway = restaurants(:subway_one)
+    assert subway.products.include?(product)
+
+    # test negative
+    product_two = products(:second_product)
+    assert !subway.products.include?(product_two)
+  end
+
+  def test_include_cpk_association_side_only
+    product = products(:first_product)
+    subway = restaurants(:subway_one)
+    product.restaurants << subway
+
+    # reload
+    # test positive
+    product = products(:first_product)
+    assert product.restaurants.include?(subway)
+
+    # test negative
+    mcdonalds = restaurants(:mcdonalds)
+    assert !product.restaurants.include?(mcdonalds)
+  end
+
+  def test_habtm_clear_cpk_both_sides
+    @restaurant = restaurants(:mcdonalds)
+    assert_equal 2, @restaurant.suburbs.size
+    @restaurant.suburbs.clear
+    assert_equal 0, @restaurant.suburbs.size
+  end
+
+  def test_habtm_clear_cpk_owner_side_only
+    subway = restaurants(:subway_one)
+    assert_equal 0, subway.products.size, 'Baseline'
+
+    first_product = products(:first_product)
+    second_product = products(:second_product)
+    subway.products << first_product << second_product
+    assert_equal 2, subway.products.size
+    subway.products.clear
+    # reload to force reload of associations
+    subway = restaurants(:subway_one)
+    assert_equal 0, subway.products.size
+  end
+
+  def test_habtm_clear_cpk_association_side_only
+    product = products(:first_product)
+    assert_equal 0, product.restaurants.size, 'Baseline'
+
+    subway_one = restaurants(:subway_one)
+    subway_two = restaurants(:subway_two)
+    product.restaurants << subway_one << subway_two
+    assert_equal 2, product.restaurants.size
+    product.restaurants.clear
+    # reload to force reload of associations
+    product = products(:first_product)
+    assert_equal 0, product.restaurants.size
+  end
+
+  # tests case reported in issue #39 where a bug resulted in
+  # deletion of incorrect join table records because the owner's id
+  # was assumed to be an array and is not in this case
+  # and evaluates to a useable but incorrect value
+  def test_habtm_clear_cpk_association_side_only_deletes_only_correct_records
+    product_one = Product.find(1)
+    product_three = Product.find(3)
+    subway_one = restaurants(:subway_one)
+    subway_two = restaurants(:subway_two)
+    product_one.restaurants << subway_one << subway_two
+    product_three.restaurants << subway_one << subway_two
+    assert_equal 2, product_one.restaurants.size
+    assert_equal 2, product_three.restaurants.size
+
+    # if product_three's id is incorrectly assumed to be
+    # an array it will be evaluated as 3[0], which is 1, which would
+    # delete product_one's associations rather than product_three's
+    product_three.restaurants.clear
+
+    # reload to force reload of associations
+    product_one = Product.find(1)
+    assert_equal 2, product_one.restaurants.size
+
+    product_three = Product.find(3)
+    assert_equal 0, product_three.restaurants.size
+  end
+end