composite_primary_keys 12.0.9 → 12.0.10

data/test/test_delete.rb

@@ -1,179 +1,182 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestDelete < ActiveSupport::TestCase
-  fixtures :articles, :departments, :employees, :products, :tariffs, :product_tariffs,
-           :reference_types, :reference_codes
-
-  def test_delete_one
-    assert_equal(5, ReferenceCode.count)
-    ReferenceCode.first.delete
-    assert_equal(4, ReferenceCode.count)
-  end
-
-  def test_delete_one_with_id
-    assert_equal(5, ReferenceCode.count)
-    ReferenceCode.delete(ReferenceCode.first.id)
-    assert_equal(4, ReferenceCode.count)
-  end
-
-  def test_destroy_one
-    assert_equal(5, ReferenceCode.count)
-    ReferenceCode.first.destroy
-    assert_equal(4, ReferenceCode.count)
-  end
-
-  def test_delete_all
-    refute_empty(ReferenceCode.all)
-    ReferenceCode.delete_all
-    assert_empty(ReferenceCode.all)
-  end
-
-  def test_delete_all_with_join
-    employee = employees(:mindy)
-
-    assert_equal(4, Department.count)
-
-    Department.joins(:employees).
-               where('employees.name = ?', employee.name).
-               delete_all
-
-    assert_equal(3, Department.count)
-  end
-
-  def test_clear_association
-    department = Department.find([1,1])
-    assert_equal(2, department.employees.size, "Before clear employee count should be 2.")
-
-    department.employees.clear
-    assert_equal(0, department.employees.size, "After clear employee count should be 0.")
-
-    department.reload
-    assert_equal(0, department.employees.size, "After clear and a reload from DB employee count should be 0.")
-  end
-
-  def test_delete_association
-    department = Department.find([1,1])
-    assert_equal 2, department.employees.size , "Before delete employee count should be 2."
-    first_employee = department.employees[0]
-    department.employees.delete(first_employee)
-    assert_equal 1, department.employees.size, "After delete employee count should be 1."
-    department.reload
-    assert_equal 1, department.employees.size, "After delete and a reload from DB employee count should be 1."
-  end
-
-  def test_has_many_replace
-    tariff = tariffs(:flat)
-    assert_equal(1, tariff.product_tariffs.length)
-
-    tariff.product_tariffs = [product_tariffs(:first_free), product_tariffs(:second_free)]
-    tariff.reload
-
-    assert_equal(2, tariff.product_tariffs.length)
-    refute(tariff.product_tariffs.include?(tariff))
-  end
-
-  def test_destroy_has_one
-    # In this case the association is a has_one with
-    # dependent set to :destroy
-    department = departments(:engineering)
-    assert_not_nil(department.head)
-
-    # Get head employee id
-    head_id = department.head.id
-
-    # Delete department - should delete the head
-    department.destroy
-
-    # Verify the head is also
-    assert_raise(ActiveRecord::RecordNotFound) do
-      Employee.find(head_id)
-    end
-  end
-
-  def test_destroy_has_and_belongs_to_many_on_non_cpk
-    steve = employees(:steve)
-    records_before = ActiveRecord::Base.connection.execute('select * from employees_groups')
-    steve.destroy
-    records_after = ActiveRecord::Base.connection.execute('select * from employees_groups')
-    if records_before.respond_to?(:count)
-      assert_equal records_after.count, records_before.count - steve.groups.count
-    elsif records_before.respond_to?(:row_count) # OCI8:Cursor for oracle adapter
-      assert_equal records_after.row_count, records_before.row_count - steve.groups.count
-    end
-  end
-
-  def test_create_destroy_has_and_belongs_to_many_on_non_cpk
-    records_before = ActiveRecord::Base.connection.execute('select * from employees_groups')
-    employee = Employee.create!(department_id: 3, location_id: 2, name: 'Jon')
-    employee.groups << Group.create(name: 'test')
-    employee.destroy!
-    records_after = ActiveRecord::Base.connection.execute('select * from employees_groups')
-    if records_before.respond_to?(:count)
-      assert_equal records_before.count, records_after.count
-    elsif records_before.respond_to?(:row_count) # OCI8:Cursor for oracle adapter
-      assert_equal records_before.row_count, records_after.row_count
-    end
-  end
-
-  def test_create_destroy_all_has_and_belongs_to_many_on_non_cpk
-    records_before = ActiveRecord::Base.connection.execute('select * from employees_groups')
-    employee = Employee.create!(department_id: 3, location_id: 2, name: 'Jon')
-    employee.groups << Group.create(name: 'test')
-    employee.groups.destroy_all
-    records_after = ActiveRecord::Base.connection.execute('select * from employees_groups')
-    if records_before.respond_to?(:count)
-      assert_equal records_before.count, records_after.count
-    elsif records_before.respond_to?(:row_count) # OCI8:Cursor for oracle adapter
-      assert_equal records_before.row_count, records_after.row_count
-    end
-  end
-
-  def test_delete_not_destroy_on_cpk
-    tariff = Tariff.where(tariff_id: 2).first
-    tariff.delete
-    refute(tariff.persisted?)
-  end
-
-  def test_delete_not_destroy_on_non_cpk
-    article = articles(:third)
-    article.delete
-    refute(article.persisted?)
-  end
-
-  def test_destroy_has_many_delete_all
-    # In this case the association is a has_many composite key with
-    # dependent set to :delete_all
-    product = Product.find(1)
-    assert_equal(2, product.product_tariffs.length)
-
-    # Get product_tariff length
-    product_tariff_size = ProductTariff.count
-
-    # Delete product - should delete 2 product tariffs
-    product.destroy
-
-    # Verify product_tariff are deleted
-    assert_equal(product_tariff_size - 2, ProductTariff.count)
-  end
-
-  def test_delete_cpk_association
-    product = Product.find(1)
-    assert_equal(2, product.product_tariffs.length)
-
-    product_tariff = product.product_tariffs.first
-    product.product_tariffs.delete(product_tariff)
-
-    product.reload
-    assert_equal(1, product.product_tariffs.length)
-  end
-
-  def test_delete_records_for_has_many_association_with_composite_primary_key
-    reference_type  = ReferenceType.find(1)
-    codes_to_delete = reference_type.reference_codes[0..1]
-    assert_equal(3, reference_type.reference_codes.size, "Before deleting records reference_code count should be 3.")
-
-    reference_type.reference_codes.delete(codes_to_delete)
-    reference_type.reload
-    assert_equal(1, reference_type.reference_codes.size, "After deleting 2 records and a reload from DB reference_code count should be 1.")
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class TestDelete < ActiveSupport::TestCase
+  fixtures :articles, :departments, :employees, :products, :tariffs, :product_tariffs,
+           :reference_types, :reference_codes
+
+  def test_delete_one
+    assert_equal(5, ReferenceCode.count)
+    ReferenceCode.first.delete
+    assert_equal(4, ReferenceCode.count)
+  end
+
+  def test_delete_one_with_id
+    assert_equal(5, ReferenceCode.count)
+    deleted = ReferenceCode.delete(ReferenceCode.first.id)
+    assert_equal(4, ReferenceCode.count)
+    assert_equal(1, deleted)
+  end
+
+  def test_destroy_one
+    assert_equal(5, ReferenceCode.count)
+    ReferenceCode.first.destroy
+    assert_equal(4, ReferenceCode.count)
+  end
+
+  def test_delete_all
+    refute_empty(ReferenceCode.all)
+    deleted = ReferenceCode.delete_all
+    assert_empty(ReferenceCode.all)
+    assert_equal(5, deleted)
+  end
+
+  def test_delete_all_with_join
+    employee = employees(:mindy)
+
+    assert_equal(4, Department.count)
+
+    deleted = Department.joins(:employees).
+                         where('employees.name = ?', employee.name).
+                         delete_all
+
+    assert_equal(3, Department.count)
+    assert_equal(1, deleted)
+  end
+
+  def test_clear_association
+    department = Department.find([1,1])
+    assert_equal(2, department.employees.size, "Before clear employee count should be 2.")
+
+    department.employees.clear
+    assert_equal(0, department.employees.size, "After clear employee count should be 0.")
+
+    department.reload
+    assert_equal(0, department.employees.size, "After clear and a reload from DB employee count should be 0.")
+  end
+
+  def test_delete_association
+    department = Department.find([1,1])
+    assert_equal 2, department.employees.size , "Before delete employee count should be 2."
+    first_employee = department.employees[0]
+    department.employees.delete(first_employee)
+    assert_equal 1, department.employees.size, "After delete employee count should be 1."
+    department.reload
+    assert_equal 1, department.employees.size, "After delete and a reload from DB employee count should be 1."
+  end
+
+  def test_has_many_replace
+    tariff = tariffs(:flat)
+    assert_equal(1, tariff.product_tariffs.length)
+
+    tariff.product_tariffs = [product_tariffs(:first_free), product_tariffs(:second_free)]
+    tariff.reload
+
+    assert_equal(2, tariff.product_tariffs.length)
+    refute(tariff.product_tariffs.include?(tariff))
+  end
+
+  def test_destroy_has_one
+    # In this case the association is a has_one with
+    # dependent set to :destroy
+    department = departments(:engineering)
+    assert_not_nil(department.head)
+
+    # Get head employee id
+    head_id = department.head.id
+
+    # Delete department - should delete the head
+    department.destroy
+
+    # Verify the head is also
+    assert_raise(ActiveRecord::RecordNotFound) do
+      Employee.find(head_id)
+    end
+  end
+
+  def test_destroy_has_and_belongs_to_many_on_non_cpk
+    steve = employees(:steve)
+    records_before = ActiveRecord::Base.connection.execute('select * from employees_groups')
+    steve.destroy
+    records_after = ActiveRecord::Base.connection.execute('select * from employees_groups')
+    if records_before.respond_to?(:count)
+      assert_equal records_after.count, records_before.count - steve.groups.count
+    elsif records_before.respond_to?(:row_count) # OCI8:Cursor for oracle adapter
+      assert_equal records_after.row_count, records_before.row_count - steve.groups.count
+    end
+  end
+
+  def test_create_destroy_has_and_belongs_to_many_on_non_cpk
+    records_before = ActiveRecord::Base.connection.execute('select * from employees_groups')
+    employee = Employee.create!(department_id: 3, location_id: 2, name: 'Jon')
+    employee.groups << Group.create(name: 'test')
+    employee.destroy!
+    records_after = ActiveRecord::Base.connection.execute('select * from employees_groups')
+    if records_before.respond_to?(:count)
+      assert_equal records_before.count, records_after.count
+    elsif records_before.respond_to?(:row_count) # OCI8:Cursor for oracle adapter
+      assert_equal records_before.row_count, records_after.row_count
+    end
+  end
+
+  def test_create_destroy_all_has_and_belongs_to_many_on_non_cpk
+    records_before = ActiveRecord::Base.connection.execute('select * from employees_groups')
+    employee = Employee.create!(department_id: 3, location_id: 2, name: 'Jon')
+    employee.groups << Group.create(name: 'test')
+    employee.groups.destroy_all
+    records_after = ActiveRecord::Base.connection.execute('select * from employees_groups')
+    if records_before.respond_to?(:count)
+      assert_equal records_before.count, records_after.count
+    elsif records_before.respond_to?(:row_count) # OCI8:Cursor for oracle adapter
+      assert_equal records_before.row_count, records_after.row_count
+    end
+  end
+
+  def test_delete_not_destroy_on_cpk
+    tariff = Tariff.where(tariff_id: 2).first
+    tariff.delete
+    refute(tariff.persisted?)
+  end
+
+  def test_delete_not_destroy_on_non_cpk
+    article = articles(:third)
+    article.delete
+    refute(article.persisted?)
+  end
+
+  def test_destroy_has_many_delete_all
+    # In this case the association is a has_many composite key with
+    # dependent set to :delete_all
+    product = Product.find(1)
+    assert_equal(2, product.product_tariffs.length)
+
+    # Get product_tariff length
+    product_tariff_size = ProductTariff.count
+
+    # Delete product - should delete 2 product tariffs
+    product.destroy
+
+    # Verify product_tariff are deleted
+    assert_equal(product_tariff_size - 2, ProductTariff.count)
+  end
+
+  def test_delete_cpk_association
+    product = Product.find(1)
+    assert_equal(2, product.product_tariffs.length)
+
+    product_tariff = product.product_tariffs.first
+    product.product_tariffs.delete(product_tariff)
+
+    product.reload
+    assert_equal(1, product.product_tariffs.length)
+  end
+
+  def test_delete_records_for_has_many_association_with_composite_primary_key
+    reference_type  = ReferenceType.find(1)
+    codes_to_delete = reference_type.reference_codes[0..1]
+    assert_equal(3, reference_type.reference_codes.size, "Before deleting records reference_code count should be 3.")
+
+    reference_type.reference_codes.delete(codes_to_delete)
+    reference_type.reload
+    assert_equal(1, reference_type.reference_codes.size, "After deleting 2 records and a reload from DB reference_code count should be 1.")
+  end
+end

data/test/test_exists.rb

@@ -1,40 +1,40 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestExists < ActiveSupport::TestCase
-  fixtures :articles, :capitols, :departments, :dorms
-  
-  def test_id
-    assert(Dorm.exists?(1))
-    refute(Dorm.exists?(-1))
-  end
-
-  def test_array
-    assert(Article.exists?(['name = ?', 'Article One']))
-    assert(!Article.exists?(['name = ?', 'Article -1']))
-  end
-
-  def test_hash
-    assert(Article.exists?('name' => 'Article One'))
-    assert(!Article.exists?('name' => 'Article -1'))
-  end
-
-  def test_cpk_id
-    assert(Department.exists?(CompositePrimaryKeys::CompositeKeys.new([1,1])))
-    assert(!Department.exists?(CompositePrimaryKeys::CompositeKeys.new([1,-1])))
-  end
-
-  def test_cpk_array_id
-    assert(Department.exists?([1,1]))
-    assert(!Department.exists?([1,-1]))
-  end
-
-  def test_cpk_array_condition
-    assert(Department.exists?(['id = ? and location_id = ?', 1, 1]))
-    assert(!Department.exists?(['id = ? and location_id = ?', 1, -1]))
-  end
-
-  def test_cpk_array_string_id
-    assert(Capitol.exists?(['The Netherlands', 'Amsterdam']))
-    assert(!Capitol.exists?(['The Netherlands', 'Paris']))
-  end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class TestExists < ActiveSupport::TestCase
+  fixtures :articles, :capitols, :departments, :dorms
+  
+  def test_id
+    assert(Dorm.exists?(1))
+    refute(Dorm.exists?(-1))
+  end
+
+  def test_array
+    assert(Article.exists?(['name = ?', 'Article One']))
+    assert(!Article.exists?(['name = ?', 'Article -1']))
+  end
+
+  def test_hash
+    assert(Article.exists?('name' => 'Article One'))
+    assert(!Article.exists?('name' => 'Article -1'))
+  end
+
+  def test_cpk_id
+    assert(Department.exists?(CompositePrimaryKeys::CompositeKeys.new([1,1])))
+    assert(!Department.exists?(CompositePrimaryKeys::CompositeKeys.new([1,-1])))
+  end
+
+  def test_cpk_array_id
+    assert(Department.exists?([1,1]))
+    assert(!Department.exists?([1,-1]))
+  end
+
+  def test_cpk_array_condition
+    assert(Department.exists?(['id = ? and location_id = ?', 1, 1]))
+    assert(!Department.exists?(['id = ? and location_id = ?', 1, -1]))
+  end
+
+  def test_cpk_array_string_id
+    assert(Capitol.exists?(['The Netherlands', 'Amsterdam']))
+    assert(!Capitol.exists?(['The Netherlands', 'Paris']))
+  end
 end

data/test/test_find.rb

@@ -1,164 +1,164 @@
-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_with_strings_with_comma_as_composite_keys
-    capitol = Capitol.create!(country: 'The USA', city: 'Washington, D.C.')
-    assert_equal ['The USA', 'Washington, D.C.'], capitol.id
-
-    assert_equal capitol, Capitol.find(['The USA', 'Washington, D.C.'])
-    assert_equal capitol, Capitol.find(capitol.to_param)
-  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("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_with_invalid_ids
-    assert_raise(::ActiveRecord::RecordNotFound) do
-      Suburb.find([-1, -1])
-    end
-  end
-
-  def test_find_with_no_ids
-    assert_raise(::ActiveRecord::RecordNotFound) do
-      Suburb.find
-    end
-  end
-
-  def test_find_last_suburb
-    suburb = Suburb.last
-    assert_equal([2,2], 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_enumerator
-    enumerator = Department.in_batches
-    enumerator.each 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(5, employees.to_a.count)
-  end
-
-  def test_expand_all
-    departments = Department.all
-    employees = Employee.where(:department => departments)
-    assert_equal(5, 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_with_strings_with_comma_as_composite_keys
+    capitol = Capitol.create!(country: 'The USA', city: 'Washington, D.C.')
+    assert_equal ['The USA', 'Washington, D.C.'], capitol.id
+
+    assert_equal capitol, Capitol.find(['The USA', 'Washington, D.C.'])
+    assert_equal capitol, Capitol.find(capitol.to_param)
+  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("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_with_invalid_ids
+    assert_raise(::ActiveRecord::RecordNotFound) do
+      Suburb.find([-1, -1])
+    end
+  end
+
+  def test_find_with_no_ids
+    assert_raise(::ActiveRecord::RecordNotFound) do
+      Suburb.find
+    end
+  end
+
+  def test_find_last_suburb
+    suburb = Suburb.last
+    assert_equal([2,2], 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_enumerator
+    enumerator = Department.in_batches
+    enumerator.each 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(5, employees.to_a.count)
+  end
+
+  def test_expand_all
+    departments = Department.all
+    employees = Employee.where(:department => departments)
+    assert_equal(5, 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