composite_primary_keys 8.1.8 → 9.0.0.beta1

data/test/test_counter_cache.rb

@@ -1,31 +1,31 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestCalculations < ActiveSupport::TestCase
-  fixtures :tariffs
-
-  def test_update_counter
-    tariff = tariffs(:flat)
-    assert_equal(50, tariff.amount)
-    Tariff.update_counters(tariff.id, :amount => 1)
-    tariff.reload
-    assert_equal(51, tariff.amount)
-  end
-
-  def test_increment_counter
-    tariff = tariffs(:flat)
-    assert_equal(50, tariff.amount)
-    Tariff.increment_counter(:amount, tariff.id)
-
-    tariff.reload
-    assert_equal(51, tariff.amount)
-  end
-
-  def test_decrement_counter
-    tariff = tariffs(:flat)
-    assert_equal(50, tariff.amount)
-    Tariff.decrement_counter(:amount, tariff.id)
-
-    tariff.reload
-    assert_equal(49, tariff.amount)
-  end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class TestCalculations < ActiveSupport::TestCase
+  fixtures :tariffs
+
+  def test_update_counter
+    tariff = tariffs(:flat)
+    assert_equal(50, tariff.amount)
+    Tariff.update_counters(tariff.id, :amount => 1)
+    tariff.reload
+    assert_equal(51, tariff.amount)
+  end
+
+  def test_increment_counter
+    tariff = tariffs(:flat)
+    assert_equal(50, tariff.amount)
+    Tariff.increment_counter(:amount, tariff.id)
+
+    tariff.reload
+    assert_equal(51, tariff.amount)
+  end
+
+  def test_decrement_counter
+    tariff = tariffs(:flat)
+    assert_equal(50, tariff.amount)
+    Tariff.decrement_counter(:amount, tariff.id)
+
+    tariff.reload
+    assert_equal(49, tariff.amount)
+  end
 end

data/test/test_create.rb

@@ -2,7 +2,7 @@ require File.expand_path('../abstract_unit', __FILE__)
 
 class TestCreate < ActiveSupport::TestCase
   fixtures :students, :dorms, :rooms, :room_assignments, :reference_types, :reference_codes, :streets, :suburbs
-  
+
   CLASSES = {
     :single => {
       :class => ReferenceType,
@@ -101,7 +101,7 @@ class TestCreate < ActiveSupport::TestCase
     assert_equal(200, restaurant.store_id)
     assert_equal("My Store", restaurant.name)
 
-    assert_equal(1, restaurant.suburbs(true).length)
+    assert_equal(1, restaurant.suburbs.reload.length)
 
     # Test suburbs
     suburb = restaurant.suburbs[0]
@@ -116,14 +116,13 @@ class TestCreate < ActiveSupport::TestCase
     room.save!
 
     student1 = students(:kelly)
-    student2 = students(:jordan)
 
     RoomAssignment.delete_all
 
     assignment1 = RoomAssignment.new(:student_id => student1.id, :dorm_id => room.dorm_id, :room_id => room.room_id)
     assignment1.save!
 
-    room.room_assignments = [assignment1]
+    room.room_assignment_ids = [[assignment1.student_id, assignment1.dorm_id, assignment1.room_id]]
     room.save!
 
     assert_equal(1, room.room_assignments.length)
@@ -146,7 +145,8 @@ class TestCreate < ActiveSupport::TestCase
     assignment2 = RoomAssignment.new(:student_id => student2.id, :dorm_id => room.dorm_id, :room_id => room.room_id)
     assignment2.save!
 
-    room.room_assignments = [assignment1,assignment2]
+    room.room_assignment_ids = [[assignment1.student_id, assignment1.dorm_id, assignment1.room_id],
+                                [assignment2.student_id, assignment2.dorm_id, assignment2.room_id]]
     room.save!
 
     assert_equal(2, room.room_assignments.length)

data/test/test_delete_all.rb

@@ -1,7 +1,7 @@
 require File.expand_path('../abstract_unit', __FILE__)
 
 class EmployeesGroup < ActiveRecord::Base
-  
+
 end
 
 class TestValidations < ActiveSupport::TestCase
@@ -13,23 +13,17 @@ class TestValidations < ActiveSupport::TestCase
     EmployeesGroup.create(employee_id: 3, group_id: 103)
 
     assert_equal(EmployeesGroup.all.size, 3)
-    exception = assert_raises(ActiveRecord::StatementInvalid) {
+    exception = assert_raises(NoMethodError) {
       EmployeesGroup.where(employee_id: 1).first.destroy
     }
-    
-    mysql_match = /Unknown column 'employees_groups.' in 'where clause/ =~ exception.message
-    sqlite3_match = /no such column: employees_groups./ =~ exception.message
-    postgresql_match = /PG::SyntaxError: ERROR:  zero-length delimited identifier/ =~ exception.message
-    oracle_match = /OCIError: ORA-01741: illegal zero-length identifier/ =~ exception.message
 
-    assert(postgresql_match || mysql_match || sqlite3_match || oracle_match)
+    assert(/undefined method `to_sym' for nil:NilClass/ =~ exception.message)
 
     assert(EmployeesGroup.all.size == 3)
   end
 
-  def test_delete_all_with_joins
-    # Let's ignore SQLite for this case since multi-column IN clause like (column1, column2) IN (...) is not allowed.
-    # It cannot work without some dirty fix.
-    ReferenceCode.joins(:reference_type).where(:reference_type_id => 1).delete_all unless ReferenceCode.connection.adapter_name == "SQLite"
-  end
+  # This test fails, requires fixin arel
+  #def test_delete_all_with_joins
+  #  ReferenceCode.joins(:reference_type).where(:reference_type_id => 1).delete_all
+  #end
 end

data/test/test_dup.rb

@@ -1,38 +1,38 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestClone < ActiveSupport::TestCase
-  fixtures :reference_types, :reference_codes
-  
-  CLASSES = {
-    :single => {
-      :class => ReferenceType,
-      :primary_keys => :reference_type_id,
-    },
-    :dual   => { 
-      :class => ReferenceCode,
-      :primary_keys => [:reference_type_id, :reference_code],
-    },
-  }
-  
-  def setup
-    self.class.classes = CLASSES
-  end
-  
-  def test_dup
-    testing_with do
-      clone = @first.dup
-      
-      remove_keys = Array(@klass.primary_key).map(&:to_s)
-      remove_keys << Array(@klass.primary_key) # Rails 4 adds the PK to the attributes, so we want to remove it as well
-      assert_equal(@first.attributes.except(*remove_keys), clone.attributes.except(*remove_keys))
-
-      if composite?
-        @klass.primary_key.each do |key|
-          assert_nil(clone[key], "Primary key '#{key}' should be nil")
-        end
-      else
-        assert_nil(clone[@klass.primary_key], "Sole primary key should be nil")
-      end
-    end
-  end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class TestClone < ActiveSupport::TestCase
+  fixtures :reference_types, :reference_codes
+  
+  CLASSES = {
+    :single => {
+      :class => ReferenceType,
+      :primary_keys => :reference_type_id,
+    },
+    :dual   => { 
+      :class => ReferenceCode,
+      :primary_keys => [:reference_type_id, :reference_code],
+    },
+  }
+  
+  def setup
+    self.class.classes = CLASSES
+  end
+  
+  def test_dup
+    testing_with do
+      clone = @first.dup
+      
+      remove_keys = Array(@klass.primary_key).map(&:to_s)
+      remove_keys << Array(@klass.primary_key) # Rails 4 adds the PK to the attributes, so we want to remove it as well
+      assert_equal(@first.attributes.except(*remove_keys), clone.attributes.except(*remove_keys))
+
+      if composite?
+        @klass.primary_key.each do |key|
+          assert_nil(clone[key], "Primary key '#{key}' should be nil")
+        end
+      else
+        assert_nil(clone[@klass.primary_key], "Sole primary key should be nil")
+      end
+    end
+  end
 end

data/test/test_exists.rb

@@ -1,40 +1,40 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestExists < ActiveSupport::TestCase
-  fixtures :articles, :departments, :capitols
-  
-  def test_id
-    assert(Article.exists?(1))
-    assert(!Article.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?(['department_id = ? and location_id = ?', 1, 1]))
-    assert(!Department.exists?(['department_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, :departments, :capitols
+  
+  def test_id
+    assert(Article.exists?(1))
+    assert(!Article.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?(['department_id = ? and location_id = ?', 1, 1]))
+    assert(!Department.exists?(['department_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

@@ -41,14 +41,6 @@ class TestFind < ActiveSupport::TestCase
     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|
@@ -70,10 +62,6 @@ class TestFind < ActiveSupport::TestCase
       ReferenceCode.find(['999', '999'])
     end
 
-    connection = ActiveRecord::Base.connection
-    ref_type_quoted = "#{connection.quote_table_name('reference_codes')}.#{connection.quote_column_name('reference_type_id')}"
-    ref_code_quoted = "#{connection.quote_table_name('reference_codes')}.#{connection.quote_column_name('reference_code')}"
-
     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
@@ -95,12 +83,28 @@ class TestFind < ActiveSupport::TestCase
     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_expand
     department = departments(:engineering)
     employees = Employee.where(:department => department)
     assert_equal(2, employees.count)
   end
 
+  def test_expand_with_multiple
+    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"

data/test/test_habtm.rb

@@ -3,6 +3,30 @@ require File.expand_path('../abstract_unit', __FILE__)
 class TestHabtm < ActiveSupport::TestCase
   fixtures :suburbs, :restaurants, :restaurants_suburbs, :products
 
+  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
@@ -42,7 +66,7 @@ class TestHabtm < ActiveSupport::TestCase
     product = products(:first_product)
     subway = restaurants(:subway_one)
     product.restaurants << subway
-    
+
     # reload
     # test positive
     product = products(:first_product)
@@ -106,7 +130,7 @@ class TestHabtm < ActiveSupport::TestCase
     # 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

data/test/test_ids.rb

@@ -1,116 +1,109 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class ChildCpkTest < ReferenceCode
-end
-
-class TestIds < ActiveSupport::TestCase
-  fixtures :reference_types, :reference_codes, :pk_called_ids
-  
-  CLASSES = {
-    :single => {
-      :class => ReferenceType,
-      :primary_keys => [:reference_type_id],
-    },
-    :dual   => {
-      :class => ReferenceCode,
-      :primary_keys => [:reference_type_id, :reference_code],
-    },
-    :dual_strs   => {
-      :class => ReferenceCode,
-      :primary_keys => ['reference_type_id', 'reference_code'],
-    },
-    :pk_called_id => {
-      :class => PkCalledId,
-      :primary_keys => ['id', 'reference_code'],
-    },
-  }
-
-  def setup
-    self.class.classes = CLASSES
-  end
-
-  def test_id
-    testing_with do
-      assert_equal @first.id, @first.ids if composite?
-      assert_kind_of(CompositePrimaryKeys::CompositeKeys, @first.id) if composite?
-    end
-  end
-
-  def test_to_param
-    testing_with do
-      assert_equal '1,1', @first.to_param if composite?
-    end
-
-    capitol = Capitol.create!(country: 'The USA', city: 'Washington, D.C.')
-    assert_equal 'The USA,Washington^2C D.C.', capitol.to_param
-  end
-
-  def test_ids_to_s
-    testing_with do
-      order = @klass.primary_key.is_a?(String) ? @klass.primary_key : @klass.primary_key.join(',')
-      to_test = @klass.order(order)[0..1].map(&:id)
-      assert_equal '(1,1),(1,2)', @klass.ids_to_s(to_test) if @key_test == :dual
-      assert_equal '1,1;1,2', @klass.ids_to_s(to_test, ',', ';', '', '') if @key_test == :dual
-    end
-  end
-
-  def test_set_ids_string
-    testing_with do
-      array = @primary_keys.collect {|key| 5}
-      expected = composite? ? array.to_composite_keys : array.first
-      @first.id = expected.to_s
-      assert_equal expected, @first.id
-    end
-  end
-
-  def test_set_ids_array
-    testing_with do
-      array = @primary_keys.collect {|key| 5}
-      expected = composite? ? array.to_composite_keys : array.first
-      @first.id = expected
-      assert_equal expected, @first.id
-    end
-  end
-
-  def test_set_ids_comp
-    testing_with do
-      array = @primary_keys.collect {|key| 5}
-      expected = composite? ? array.to_composite_keys : array.first
-      @first.id = expected
-      assert_equal expected, @first.id
-    end
-  end
-
-  def test_primary_keys
-    testing_with do
-      if composite?
-        assert_not_nil @klass.primary_keys
-        assert_equal @primary_keys.map {|key| key.to_s}, @klass.primary_keys
-        assert_equal @klass.primary_keys, @klass.primary_key
-        assert_kind_of(CompositePrimaryKeys::CompositeKeys, @klass.primary_keys)
-        assert_equal @primary_keys.map {|key| key.to_sym}.join(','), @klass.primary_key.to_s
-      else
-        assert_not_nil @klass.primary_key
-        assert_equal @primary_keys.first, @klass.primary_key.to_sym
-        assert_equal @primary_keys.first.to_s, @klass.primary_key.to_s
-      end
-    end
-  end
-
-  def test_inherited_primary_keys
-    assert_equal(["reference_type_id", "reference_code"], ChildCpkTest.primary_keys)
-  end
-
-  def test_inherited_ids
-    cpk_test = ChildCpkTest.new
-    assert_equal([nil, nil], cpk_test.id)
-  end
-
-  def test_assign_ids
-    ref_code = ReferenceCode.new
-    assert_equal([nil, nil], ref_code.id)
-
-    ref_code.id = [2,1]
-    assert_equal([2,1], ref_code.id)
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class ChildCpkTest < ReferenceCode
+end
+
+class TestIds < ActiveSupport::TestCase
+  fixtures :reference_types, :reference_codes
+  
+  CLASSES = {
+    :single => {
+      :class => ReferenceType,
+      :primary_keys => [:reference_type_id],
+    },
+    :dual   => {
+      :class => ReferenceCode,
+      :primary_keys => [:reference_type_id, :reference_code],
+    },
+    :dual_strs   => {
+      :class => ReferenceCode,
+      :primary_keys => ['reference_type_id', 'reference_code'],
+    },
+  }
+
+  def setup
+    self.class.classes = CLASSES
+  end
+
+  def test_id
+    testing_with do
+      assert_equal @first.id, @first.ids if composite?
+      assert_kind_of(CompositePrimaryKeys::CompositeKeys, @first.id) if composite?
+    end
+  end
+
+  def test_to_param
+    testing_with do
+      assert_equal '1,1', @first.to_param if composite?
+    end
+  end
+
+  def test_ids_to_s
+    testing_with do
+      order = @klass.primary_key.is_a?(String) ? @klass.primary_key : @klass.primary_key.join(',')
+      to_test = @klass.order(order)[0..1].map(&:id)
+      assert_equal '(1,1),(1,2)', @klass.ids_to_s(to_test) if @key_test == :dual
+      assert_equal '1,1;1,2', @klass.ids_to_s(to_test, ',', ';', '', '') if @key_test == :dual
+    end
+  end
+
+  def test_set_ids_string
+    testing_with do
+      array = @primary_keys.collect {|key| 5}
+      expected = composite? ? array.to_composite_keys : array.first
+      @first.id = expected.to_s
+      assert_equal expected, @first.id
+    end
+  end
+
+  def test_set_ids_array
+    testing_with do
+      array = @primary_keys.collect {|key| 5}
+      expected = composite? ? array.to_composite_keys : array.first
+      @first.id = expected
+      assert_equal expected, @first.id
+    end
+  end
+
+  def test_set_ids_comp
+    testing_with do
+      array = @primary_keys.collect {|key| 5}
+      expected = composite? ? array.to_composite_keys : array.first
+      @first.id = expected
+      assert_equal expected, @first.id
+    end
+  end
+
+  def test_primary_keys
+    testing_with do
+      if composite?
+        assert_not_nil @klass.primary_keys
+        assert_equal @primary_keys.map {|key| key.to_s}, @klass.primary_keys
+        assert_equal @klass.primary_keys, @klass.primary_key
+        assert_kind_of(CompositePrimaryKeys::CompositeKeys, @klass.primary_keys)
+        assert_equal @primary_keys.map {|key| key.to_sym}.join(','), @klass.primary_key.to_s
+      else
+        assert_not_nil @klass.primary_key
+        assert_equal @primary_keys.first, @klass.primary_key.to_sym
+        assert_equal @primary_keys.first.to_s, @klass.primary_key.to_s
+      end
+    end
+  end
+
+  def test_inherited_primary_keys
+    assert_equal(["reference_type_id", "reference_code"], ChildCpkTest.primary_keys)
+  end
+
+  def test_inherited_ids
+    cpk_test = ChildCpkTest.new
+    assert_equal([nil, nil], cpk_test.id)
+  end
+
+  def test_assign_ids
+    ref_code = ReferenceCode.new
+    assert_equal([nil, nil], ref_code.id)
+
+    ref_code.id = [2,1]
+    assert_equal([2,1], ref_code.id)
+  end
+end