composite_primary_keys 13.0.1 → 14.0.1

data/test/test_composite_arrays.rb

@@ -1,38 +1,38 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class CompositeArraysTest < ActiveSupport::TestCase
-
-  def test_new_primary_keys
-    keys = CompositePrimaryKeys::CompositeKeys.new
-    assert_not_nil keys
-    assert_equal '', keys.to_s
-    assert_equal '', "#{keys}"
-  end
-
-  def test_initialize_primary_keys
-    keys = CompositePrimaryKeys::CompositeKeys.new([1,2,3])
-    assert_not_nil keys
-    assert_equal '1,2,3', keys.to_s
-    assert_equal '1,2,3', "#{keys}"
-  end
-
-  def test_to_composite_keys
-    keys = [1,2,3].to_composite_keys
-    assert_equal CompositePrimaryKeys::CompositeKeys, keys.class
-    assert_equal '1,2,3', keys.to_s
-  end
-
-  def test_parse
-    assert_equal ['1', '2'], CompositePrimaryKeys::CompositeKeys.parse('1,2')
-    assert_equal ['The USA', '^Washington, D.C.'],
-                 CompositePrimaryKeys::CompositeKeys.parse('The USA,^5EWashington^2C D.C.')
-    assert_equal ['The USA', '^Washington, D.C.'],
-                 CompositePrimaryKeys::CompositeKeys.parse(['The USA', '^Washington, D.C.'])
-  end
-
-  def test_to_s
-    assert_equal '1,2', CompositePrimaryKeys::CompositeKeys.new([1, 2]).to_s
-    assert_equal 'The USA,^5EWashington^2C D.C.',
-                 CompositePrimaryKeys::CompositeKeys.new(['The USA', '^Washington, D.C.']).to_s
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class CompositeArraysTest < ActiveSupport::TestCase
+
+  def test_new_primary_keys
+    keys = CompositePrimaryKeys::CompositeKeys.new
+    assert_not_nil keys
+    assert_equal '', keys.to_s
+    assert_equal '', "#{keys}"
+  end
+
+  def test_initialize_primary_keys
+    keys = CompositePrimaryKeys::CompositeKeys.new([1,2,3])
+    assert_not_nil keys
+    assert_equal '1,2,3', keys.to_s
+    assert_equal '1,2,3', "#{keys}"
+  end
+
+  def test_to_composite_keys
+    keys = [1,2,3].to_composite_keys
+    assert_equal CompositePrimaryKeys::CompositeKeys, keys.class
+    assert_equal '1,2,3', keys.to_s
+  end
+
+  def test_parse
+    assert_equal ['1', '2'], CompositePrimaryKeys::CompositeKeys.parse('1,2')
+    assert_equal ['The USA', '^Washington, D.C.'],
+                 CompositePrimaryKeys::CompositeKeys.parse('The USA,^5EWashington^2C D.C.')
+    assert_equal ['The USA', '^Washington, D.C.'],
+                 CompositePrimaryKeys::CompositeKeys.parse(['The USA', '^Washington, D.C.'])
+  end
+
+  def test_to_s
+    assert_equal '1,2', CompositePrimaryKeys::CompositeKeys.new([1, 2]).to_s
+    assert_equal 'The USA,^5EWashington^2C D.C.',
+                 CompositePrimaryKeys::CompositeKeys.new(['The USA', '^Washington, D.C.']).to_s
+  end
+end

data/test/test_counter_cache.rb

@@ -1,31 +1,31 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestCounterCache < ActiveSupport::TestCase
-  fixtures :dorms, :rooms, :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 TestCounterCache < ActiveSupport::TestCase
+  fixtures :dorms, :rooms, :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_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_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_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_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

data/test/test_miscellaneous.rb

@@ -1,32 +1,32 @@
-require File.expand_path('../abstract_unit', __FILE__)
-
-class TestMiscellaneous < ActiveSupport::TestCase
-  fixtures :reference_types, :reference_codes, :products
-  
-  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_composite_class
-    testing_with do
-      assert_equal composite?, @klass.composite?
-    end
-  end
-
-  def test_composite_instance
-    testing_with do
-      assert_equal composite?, @first.composite?
-    end
-  end
-end
+require File.expand_path('../abstract_unit', __FILE__)
+
+class TestMiscellaneous < ActiveSupport::TestCase
+  fixtures :reference_types, :reference_codes, :products
+  
+  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_composite_class
+    testing_with do
+      assert_equal composite?, @klass.composite?
+    end
+  end
+
+  def test_composite_instance
+    testing_with do
+      assert_equal composite?, @first.composite?
+    end
+  end
+end