diff options
Diffstat (limited to 'activesupport/test/ordered_hash_test.rb')
| -rw-r--r-- | activesupport/test/ordered_hash_test.rb | 324 |
1 files changed, 324 insertions, 0 deletions
diff --git a/activesupport/test/ordered_hash_test.rb b/activesupport/test/ordered_hash_test.rb new file mode 100644 index 0000000000..c70d3b4c37 --- /dev/null +++ b/activesupport/test/ordered_hash_test.rb @@ -0,0 +1,324 @@ +# frozen_string_literal: true + +require "abstract_unit" +require "active_support/json" +require "active_support/core_ext/object/json" +require "active_support/core_ext/hash/indifferent_access" +require "active_support/core_ext/array/extract_options" + +class OrderedHashTest < ActiveSupport::TestCase + def setup + @keys = %w( blue green red pink orange ) + @values = %w( 000099 009900 aa0000 cc0066 cc6633 ) + @hash = Hash.new + @ordered_hash = ActiveSupport::OrderedHash.new + + @keys.each_with_index do |key, index| + @hash[key] = @values[index] + @ordered_hash[key] = @values[index] + end + end + + def test_order + assert_equal @keys, @ordered_hash.keys + assert_equal @values, @ordered_hash.values + end + + def test_access + assert @hash.all? { |k, v| @ordered_hash[k] == v } + end + + def test_assignment + key, value = "purple", "5422a8" + + @ordered_hash[key] = value + assert_equal @keys.length + 1, @ordered_hash.length + assert_equal key, @ordered_hash.keys.last + assert_equal value, @ordered_hash.values.last + assert_equal value, @ordered_hash[key] + end + + def test_delete + key, value = "white", "ffffff" + bad_key = "black" + + @ordered_hash[key] = value + assert_equal @keys.length + 1, @ordered_hash.length + assert_equal @ordered_hash.keys.length, @ordered_hash.length + + assert_equal value, @ordered_hash.delete(key) + assert_equal @keys.length, @ordered_hash.length + assert_equal @ordered_hash.keys.length, @ordered_hash.length + + assert_nil @ordered_hash.delete(bad_key) + end + + def test_to_hash + assert_same @ordered_hash, @ordered_hash.to_hash + end + + def test_to_a + assert_equal @keys.zip(@values), @ordered_hash.to_a + end + + def test_has_key + assert_equal true, @ordered_hash.has_key?("blue") + assert_equal true, @ordered_hash.key?("blue") + assert_equal true, @ordered_hash.include?("blue") + assert_equal true, @ordered_hash.member?("blue") + + assert_equal false, @ordered_hash.has_key?("indigo") + assert_equal false, @ordered_hash.key?("indigo") + assert_equal false, @ordered_hash.include?("indigo") + assert_equal false, @ordered_hash.member?("indigo") + end + + def test_has_value + assert_equal true, @ordered_hash.has_value?("000099") + assert_equal true, @ordered_hash.value?("000099") + assert_equal false, @ordered_hash.has_value?("ABCABC") + assert_equal false, @ordered_hash.value?("ABCABC") + end + + def test_each_key + keys = [] + assert_equal @ordered_hash, @ordered_hash.each_key { |k| keys << k } + assert_equal @keys, keys + assert_kind_of Enumerator, @ordered_hash.each_key + end + + def test_each_value + values = [] + assert_equal @ordered_hash, @ordered_hash.each_value { |v| values << v } + assert_equal @values, values + assert_kind_of Enumerator, @ordered_hash.each_value + end + + def test_each + values = [] + assert_equal @ordered_hash, @ordered_hash.each { |key, value| values << value } + assert_equal @values, values + assert_kind_of Enumerator, @ordered_hash.each + end + + def test_each_with_index + @ordered_hash.each_with_index { |pair, index| assert_equal [@keys[index], @values[index]], pair } + end + + def test_each_pair + values = [] + keys = [] + @ordered_hash.each_pair do |key, value| + keys << key + values << value + end + assert_equal @values, values + assert_equal @keys, keys + assert_kind_of Enumerator, @ordered_hash.each_pair + end + + def test_find_all + assert_equal @keys, @ordered_hash.find_all { true }.map(&:first) + end + + def test_select + new_ordered_hash = @ordered_hash.select { true } + assert_equal @keys, new_ordered_hash.map(&:first) + assert_instance_of ActiveSupport::OrderedHash, new_ordered_hash + end + + def test_delete_if + copy = @ordered_hash.dup + copy.delete("pink") + assert_equal copy, @ordered_hash.delete_if { |k, _| k == "pink" } + assert_not_includes @ordered_hash.keys, "pink" + end + + def test_reject! + (copy = @ordered_hash.dup).delete("pink") + @ordered_hash.reject! { |k, _| k == "pink" } + assert_equal copy, @ordered_hash + assert_not_includes @ordered_hash.keys, "pink" + end + + def test_reject + copy = @ordered_hash.dup + new_ordered_hash = @ordered_hash.reject { |k, _| k == "pink" } + assert_equal copy, @ordered_hash + assert_not_includes new_ordered_hash.keys, "pink" + assert_includes @ordered_hash.keys, "pink" + assert_instance_of ActiveSupport::OrderedHash, new_ordered_hash + end + + def test_clear + @ordered_hash.clear + assert_equal [], @ordered_hash.keys + end + + def test_merge + other_hash = ActiveSupport::OrderedHash.new + other_hash["purple"] = "800080" + other_hash["violet"] = "ee82ee" + merged = @ordered_hash.merge other_hash + assert_equal merged.length, @ordered_hash.length + other_hash.length + assert_equal @keys + ["purple", "violet"], merged.keys + end + + def test_merge_with_block + hash = ActiveSupport::OrderedHash.new + hash[:a] = 0 + hash[:b] = 0 + merged = hash.merge(b: 2, c: 7) do |key, old_value, new_value| + new_value + 1 + end + + assert_equal 0, merged[:a] + assert_equal 3, merged[:b] + assert_equal 7, merged[:c] + end + + def test_merge_bang_with_block + hash = ActiveSupport::OrderedHash.new + hash[:a] = 0 + hash[:b] = 0 + hash.merge!(a: 1, c: 7) do |key, old_value, new_value| + new_value + 3 + end + + assert_equal 4, hash[:a] + assert_equal 0, hash[:b] + assert_equal 7, hash[:c] + end + + def test_shift + pair = @ordered_hash.shift + assert_equal [@keys.first, @values.first], pair + assert_not_includes @ordered_hash.keys, pair.first + end + + def test_keys + original = @ordered_hash.keys.dup + @ordered_hash.keys.pop + assert_equal original, @ordered_hash.keys + end + + def test_inspect + assert_includes @ordered_hash.inspect, @hash.inspect + end + + def test_json + ordered_hash = ActiveSupport::OrderedHash[:foo, :bar] + hash = Hash[:foo, :bar] + assert_equal ordered_hash.to_json, hash.to_json + end + + def test_alternate_initialization_with_splat + alternate = ActiveSupport::OrderedHash[1, 2, 3, 4] + assert_kind_of ActiveSupport::OrderedHash, alternate + assert_equal [1, 3], alternate.keys + end + + def test_alternate_initialization_with_array + alternate = ActiveSupport::OrderedHash[ [ + [1, 2], + [3, 4], + [ "missing value" ] + ]] + + assert_kind_of ActiveSupport::OrderedHash, alternate + assert_equal [1, 3, "missing value"], alternate.keys + assert_equal [2, 4, nil ], alternate.values + end + + def test_alternate_initialization_raises_exception_on_odd_length_args + assert_raises ArgumentError do + ActiveSupport::OrderedHash[1, 2, 3, 4, 5] + end + end + + def test_replace_updates_keys + @other_ordered_hash = ActiveSupport::OrderedHash[:black, "000000", :white, "000000"] + original = @ordered_hash.replace(@other_ordered_hash) + assert_same original, @ordered_hash + assert_equal @other_ordered_hash.keys, @ordered_hash.keys + end + + def test_nested_under_indifferent_access + flash = { a: ActiveSupport::OrderedHash[:b, 1, :c, 2] }.with_indifferent_access + assert_kind_of ActiveSupport::OrderedHash, flash[:a] + end + + def test_each_after_yaml_serialization + assert_equal @values, YAML.load(YAML.dump(@ordered_hash)).values + end + + def test_each_when_yielding_to_block_with_splat + hash_values = [] + ordered_hash_values = [] + + @hash.each { |*v| hash_values << v } + @ordered_hash.each { |*v| ordered_hash_values << v } + + assert_equal hash_values.sort, ordered_hash_values.sort + end + + def test_each_pair_when_yielding_to_block_with_splat + hash_values = [] + ordered_hash_values = [] + + @hash.each_pair { |*v| hash_values << v } + @ordered_hash.each_pair { |*v| ordered_hash_values << v } + + assert_equal hash_values.sort, ordered_hash_values.sort + end + + def test_order_after_yaml_serialization + @deserialized_ordered_hash = YAML.load(YAML.dump(@ordered_hash)) + + assert_equal @keys, @deserialized_ordered_hash.keys + assert_equal @values, @deserialized_ordered_hash.values + end + + def test_order_after_yaml_serialization_with_nested_arrays + @ordered_hash[:array] = %w(a b c) + + @deserialized_ordered_hash = YAML.load(YAML.dump(@ordered_hash)) + + assert_equal @ordered_hash.keys, @deserialized_ordered_hash.keys + assert_equal @ordered_hash.values, @deserialized_ordered_hash.values + end + + def test_psych_serialize + @deserialized_ordered_hash = Psych.load(Psych.dump(@ordered_hash)) + + values = @deserialized_ordered_hash.map { |_, value| value } + assert_equal @values, values + end + + def test_psych_serialize_tag + yaml = Psych.dump(@ordered_hash) + assert_match "!omap", yaml + end + + def test_has_yaml_tag + @ordered_hash[:array] = %w(a b c) + assert_match "!omap", YAML.dump(@ordered_hash) + end + + def test_update_sets_keys + @updated_ordered_hash = ActiveSupport::OrderedHash.new + @updated_ordered_hash.update(name: "Bob") + assert_equal [:name], @updated_ordered_hash.keys + end + + def test_invert + expected = ActiveSupport::OrderedHash[@values.zip(@keys)] + assert_equal expected, @ordered_hash.invert + assert_equal @values.zip(@keys), @ordered_hash.invert.to_a + end + + def test_extractable + @ordered_hash[:rails] = "snowman" + assert_equal @ordered_hash, [1, 2, @ordered_hash].extract_options! + end +end |