motion-support 0.1.0 → 0.2.0

data/spec/motion-support/hash_with_indifferent_access_spec.rb

@@ -0,0 +1,605 @@
+class IndifferentHash < MotionSupport::HashWithIndifferentAccess
+end
+
+class SubclassingArray < Array
+end
+
+class SubclassingHash < Hash
+end
+
+class NonIndifferentHash < Hash
+  def nested_under_indifferent_access
+    self
+  end
+end
+
+describe "HashWithIndifferentAccess" do
+  before do
+    @strings = { 'a' => 1, 'b' => 2 }
+    @nested_strings = { 'a' => { 'b' => { 'c' => 3 } } }
+    @symbols = { :a  => 1, :b  => 2 }
+    @nested_symbols = { :a => { :b => { :c => 3 } } }
+    @mixed   = { :a  => 1, 'b' => 2 }
+    @nested_mixed   = { 'a' => { :b => { 'c' => 3 } } }
+    @fixnums = {  0  => 1,  1  => 2 }
+    @nested_fixnums = {  0  => { 1  => { 2 => 3} } }
+    @illegal_symbols = { [] => 3 }
+    @nested_illegal_symbols = { [] => { [] => 3} }
+    @upcase_strings = { 'A' => 1, 'B' => 2 }
+    @nested_upcase_strings = { 'A' => { 'B' => { 'C' => 3 } } }
+  end
+  
+  describe "constructor" do
+    it "should construct hash" do
+      hash = HashWithIndifferentAccess[:foo, 1]
+      hash[:foo].should == 1
+      hash['foo'].should == 1
+      hash[:foo] = 3
+      hash[:foo].should == 3
+      hash['foo'].should == 3
+    end
+    
+    it "should return duplicate for with_indifferent_access" do
+      hash_wia = HashWithIndifferentAccess.new
+      hash_wia.with_indifferent_access.should == hash_wia
+      hash_wia.with_indifferent_access.object_id.should.not == hash_wia.object_id
+    end
+  end
+  
+  describe "conversion" do
+    it "should not convert other key objects" do
+      original = {Object.new => 2, 1 => 2, [] => true}
+      indiff = original.with_indifferent_access
+      indiff.keys.any? {|k| k.kind_of? String}.should == false
+    end
+  end
+  
+  describe "symbolize_keys" do
+    it "should return normal hash instance" do
+      @symbols.with_indifferent_access.symbolize_keys.should.is_a Hash
+    end
+    
+    it "should symbolize keys" do
+      @symbols.with_indifferent_access.symbolize_keys.should == @symbols
+      @strings.with_indifferent_access.symbolize_keys.should == @symbols
+      @mixed.with_indifferent_access.symbolize_keys.should == @symbols
+    end
+    
+    it "should preserve keys that can't be symbolized" do
+      @illegal_symbols.with_indifferent_access.symbolize_keys.should == @illegal_symbols
+      lambda { @illegal_symbols.with_indifferent_access.dup.symbolize_keys! }.should.raise NoMethodError
+    end
+    
+    it "should preserve Fixnum keys" do
+      @fixnums.with_indifferent_access.symbolize_keys.should == @fixnums
+      lambda { @fixnums.with_indifferent_access.dup.symbolize_keys! }.should.raise NoMethodError
+    end
+    
+    it "should preserve hash" do
+      h = HashWithIndifferentAccess.new
+      h['first'] = 1
+      h = h.symbolize_keys
+      h[:first].should == 1
+    end
+  end
+  
+  describe "symbolize_keys!" do
+    it "should not work" do
+      lambda { @symbols.with_indifferent_access.dup.symbolize_keys! }.should.raise NoMethodError
+      lambda { @strings.with_indifferent_access.dup.symbolize_keys! }.should.raise NoMethodError
+      lambda { @mixed.with_indifferent_access.dup.symbolize_keys! }.should.raise NoMethodError
+    end
+  end
+  
+  describe "deep_symbolize_keys" do
+    it "should return normal hash instance" do
+      @symbols.with_indifferent_access.deep_symbolize_keys.should.is_a Hash
+    end
+    
+    it "should deep symbolize keys" do
+      @nested_symbols.with_indifferent_access.deep_symbolize_keys.should == @nested_symbols
+      @nested_strings.with_indifferent_access.deep_symbolize_keys.should == @nested_symbols
+      @nested_mixed.with_indifferent_access.deep_symbolize_keys.should == @nested_symbols
+    end
+    
+    it "should preserve keys that can't be symbolized" do
+      @nested_illegal_symbols.with_indifferent_access.deep_symbolize_keys.should == @nested_illegal_symbols
+      lambda { @nested_illegal_symbols.with_indifferent_access.deep_dup.deep_symbolize_keys! }.should.raise NoMethodError
+    end
+    
+    it "should preserve Fixnum keys for" do
+      @nested_fixnums.with_indifferent_access.deep_symbolize_keys.should == @nested_fixnums
+      lambda { @nested_fixnums.with_indifferent_access.deep_dup.deep_symbolize_keys! }.should.raise NoMethodError
+    end
+    
+    it "should preserve hash" do
+      h = HashWithIndifferentAccess.new
+      h['first'] = 1
+      h = h.deep_symbolize_keys
+      h[:first].should == 1
+    end
+  end
+  
+  describe "deep_symbolize_keys!" do
+    it "should not work" do
+      lambda { @nested_symbols.with_indifferent_access.deep_dup.deep_symbolize_keys! }.should.raise NoMethodError
+      lambda { @nested_strings.with_indifferent_access.deep_dup.deep_symbolize_keys! }.should.raise NoMethodError
+      lambda { @nested_mixed.with_indifferent_access.deep_dup.deep_symbolize_keys! }.should.raise NoMethodError
+    end
+  end
+  
+  describe "stringify_keys" do
+    it "should return hash with indifferent access" do
+      @symbols.with_indifferent_access.stringify_keys.should.is_a MotionSupport::HashWithIndifferentAccess
+    end
+    
+    it "should stringify keys" do
+      @symbols.with_indifferent_access.stringify_keys.should == @strings
+      @strings.with_indifferent_access.stringify_keys.should == @strings
+      @mixed.with_indifferent_access.stringify_keys.should == @strings
+    end
+    
+    it "should preserve hash" do
+      h = HashWithIndifferentAccess.new
+      h[:first] = 1
+      h = h.stringify_keys
+      h['first'].should == 1
+    end
+  end
+  
+  describe "deep_stringify_keys" do
+    it "should return hash with indifferent access" do
+      @nested_symbols.with_indifferent_access.deep_stringify_keys.should.is_a MotionSupport::HashWithIndifferentAccess
+    end
+    
+    it "should deep stringify keys" do
+      @nested_symbols.with_indifferent_access.deep_stringify_keys.should == @nested_strings
+      @nested_strings.with_indifferent_access.deep_stringify_keys.should == @nested_strings
+      @nested_mixed.with_indifferent_access.deep_stringify_keys.should == @nested_strings
+    end
+    
+    it "should preserve hash" do
+      h = HashWithIndifferentAccess.new
+      h[:first] = 1
+      h = h.deep_stringify_keys
+      h['first'].should == 1
+    end
+  end
+  
+  describe "stringify_keys!" do
+    it "should return hash with indifferent access" do
+      @symbols.with_indifferent_access.dup.stringify_keys!.should.is_a MotionSupport::HashWithIndifferentAccess
+    end
+
+    it "should stringify keys (for dupped instance)" do
+      @symbols.with_indifferent_access.dup.stringify_keys!.should == @strings
+      @strings.with_indifferent_access.dup.stringify_keys!.should == @strings
+      @mixed.with_indifferent_access.dup.stringify_keys!.should == @strings
+    end
+  end
+  
+  describe "deep_stringify_keys!" do
+    it "should return hash with indifferent access" do
+      @nested_symbols.with_indifferent_access.dup.deep_stringify_keys!.should.is_a MotionSupport::HashWithIndifferentAccess
+    end
+
+    it "should stringify keys (for deep_dupped instance)" do
+      @nested_symbols.with_indifferent_access.deep_dup.deep_stringify_keys!.should == @nested_strings
+      @nested_strings.with_indifferent_access.deep_dup.deep_stringify_keys!.should == @nested_strings
+      @nested_mixed.with_indifferent_access.deep_dup.deep_stringify_keys!.should == @nested_strings
+    end
+  end
+  
+  describe "reading" do
+    it "should read string keys with symbol access" do
+      hash = HashWithIndifferentAccess.new
+      hash["a"] = 1
+      hash["b"] = true
+      hash["c"] = false
+      hash["d"] = nil
+
+      hash[:a].should == 1
+      hash[:b].should == true
+      hash[:c].should == false
+      hash[:d].should == nil
+      hash[:e].should == nil
+    end
+    
+    it "should read string keys with symbol access and nonnil default" do
+      hash = HashWithIndifferentAccess.new(1)
+      hash["a"] = 1
+      hash["b"] = true
+      hash["c"] = false
+      hash["d"] = nil
+
+      hash[:a].should == 1
+      hash[:b].should == true
+      hash[:c].should == false
+      hash[:d].should == nil
+      hash[:e].should == 1
+    end
+    
+    it "should return the same object that is stored" do
+      hash = HashWithIndifferentAccess.new {|h, k| h[k] = []}
+      hash[:a] << 1
+
+      hash[:a].should == [1]
+    end
+  end
+  
+  describe "writing" do
+    it "should write with symbols and strings" do
+      hash = HashWithIndifferentAccess.new
+      hash[:a] = 1
+      hash['b'] = 2
+
+      hash['a'].should == 1
+      hash['b'].should == 2
+      hash[:a].should == 1
+      hash[:b].should == 2
+    end
+    
+    it "should not symbolize or stringify numbers" do
+      hash = HashWithIndifferentAccess.new
+      hash[3] = 3
+
+      hash[3].should == 3
+      hash[:'3'].should == nil
+      hash['3'].should == nil
+    end
+    
+    it "should store values" do
+      hash = HashWithIndifferentAccess.new
+      hash.store(:test1, 1)
+      hash.store('test1', 11)
+      hash[:test2] = 2
+      hash['test2'] = 22
+      expected = { "test1" => 11, "test2" => 22 }
+      hash.should == expected
+    end
+  end
+  
+  describe "update" do
+    before do
+      @hash = HashWithIndifferentAccess.new
+      @hash[:a] = 'a'
+      @hash['b'] = 'b'
+    end
+    
+    it "should update with string keys" do
+      updated_with_strings = @hash.update(@strings)
+      updated_with_strings[:a].should == 1
+      updated_with_strings['a'].should == 1
+      updated_with_strings['b'].should == 2
+
+      updated_with_strings.keys.size.should == 2
+    end
+    
+    it "should update with symbol keys" do
+      updated_with_symbols = @hash.update(@symbols)
+      updated_with_symbols[:a].should == 1
+      updated_with_symbols['b'].should == 2
+      updated_with_symbols[:b].should == 2
+      
+      updated_with_symbols.keys.size.should == 2
+    end
+    
+    it "should update with mixed keys" do
+      updated_with_mixed = @hash.update(@mixed)
+      updated_with_mixed[:a].should == 1
+      updated_with_mixed['b'].should == 2
+      
+      updated_with_mixed.keys.size.should == 2
+    end
+  end
+  
+  describe "merge" do
+    describe "without block" do
+      before do
+        @hash = HashWithIndifferentAccess.new
+        @hash[:a] = 'failure'
+        @hash['b'] = 'failure'
+
+        @other = { 'a' => 1, :b => 2 }
+      end
+
+      it "should merge with mixed hash" do
+        merged = @hash.merge(@other)
+
+        merged.class.should == HashWithIndifferentAccess
+        merged[:a].should == 1
+        merged['b'].should == 2
+      end
+
+      it "should have the same effect inplace when updating" do
+        @hash.update(@other)
+
+        @hash[:a].should == 1
+        @hash['b'].should == 2
+      end
+    end
+    
+    describe "with block" do
+      before do
+        @hash = HashWithIndifferentAccess.new
+        @hash[:a] = 1
+        @hash['b'] = 3
+      end
+      
+      it "should merge with block" do
+        other = { 'a' => 4, :b => 2, 'c' => 10 }
+
+        merged = @hash.merge(other) { |key, old, new| old > new ? old : new }
+
+        merged.class.should == HashWithIndifferentAccess
+        merged[:a].should == 4
+        merged['b'].should == 3
+        merged[:c].should == 10
+      end
+
+      it "should merge with block one more time" do
+        other_indifferent = HashWithIndifferentAccess.new('a' => 9, :b => 2)
+
+        merged = @hash.merge(other_indifferent) { |key, old, new| old + new }
+
+        merged.class.should == HashWithIndifferentAccess
+        merged[:a].should == 10
+        merged[:b].should == 5
+      end
+    end
+  end
+  
+  describe "reverse_merge" do
+    it "should reverse merge" do
+      hash = HashWithIndifferentAccess.new('some' => 'value', 'other' => 'value')
+      hash.reverse_merge!(:some => 'noclobber', :another => 'clobber')
+      hash[:some].should == 'value'
+      hash[:another].should == 'clobber'
+    end
+  end
+  
+  describe "replace" do
+    before do
+      @hash = HashWithIndifferentAccess.new
+      @hash[:a] = 42
+
+      @replaced = @hash.replace(b: 12)
+    end
+    
+    it "should replace with regular hash" do
+      @hash.key?('b').should == true
+      @hash.key?(:a).should == false
+      @hash[:b].should == 12
+    end
+    
+    it "should be the same class" do
+      @replaced.class.should == HashWithIndifferentAccess
+    end
+    
+    it "should be the same object" do
+      @hash.object_id.should == @replaced.object_id
+    end
+  end
+  
+  describe "delete" do
+    before do
+      @hash = { :a => 'foo' }.with_indifferent_access
+    end
+    
+    it "should delete with symbol keys" do
+      @hash.delete(:a).should == 'foo'
+      @hash.delete(:a).should == nil
+    end
+    
+    it "should delete with string keys" do
+      @hash.delete('a').should == 'foo'
+      @hash.delete('a').should == nil
+    end
+  end
+  
+  describe "to_hash" do
+    it "should return a hash with string keys" do
+      @mixed.with_indifferent_access.to_hash.should == @strings
+    end
+
+    it "should preserve the default value" do
+      mixed_with_default = @mixed.dup
+      mixed_with_default.default = '1234'
+      roundtrip = mixed_with_default.with_indifferent_access.to_hash
+      roundtrip.should == @strings
+      roundtrip.default.should == '1234'
+    end
+  end
+  
+  describe "to_options" do
+    it "should preserve hash" do
+      h = HashWithIndifferentAccess.new
+      h['first'] = 1
+      h.to_options!
+      h['first'].should == 1
+    end
+  end
+  
+  describe "nesting" do
+    it "should preserve hash subclasses in nested hashes" do
+      foo = { "foo" => SubclassingHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+      foo["foo"].should.is_a MotionSupport::HashWithIndifferentAccess
+
+      foo = { "foo" => NonIndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+      foo["foo"].should.is_a NonIndifferentHash
+
+      foo = { "foo" => IndifferentHash.new.tap { |h| h["bar"] = "baz" } }.with_indifferent_access
+      foo["foo"].should.is_a IndifferentHash
+    end
+    
+    it "should deep apply indifferent access" do
+      hash = { "urls" => { "url" => [ { "address" => "1" }, { "address" => "2" } ] }}.with_indifferent_access
+      hash[:urls][:url].first[:address].should == "1"
+    end
+    
+    it "should preserve array subclass when value is array" do
+      array = SubclassingArray.new
+      array << { "address" => "1" }
+      hash = { "urls" => { "url" => array }}.with_indifferent_access
+      hash[:urls][:url].class.should == SubclassingArray
+    end
+
+    it "should preserve array class when hash value is frozen array" do
+      array = SubclassingArray.new
+      array << { "address" => "1" }
+      hash = { "urls" => { "url" => array.freeze }}.with_indifferent_access
+      hash[:urls][:url].class.should == SubclassingArray
+    end
+    
+    it "should allow indifferent access on sub hashes" do
+      h = {'user' => {'id' => 5}}.with_indifferent_access
+      ['user', :user].each { |user| [:id, 'id'].each { |id| h[user][id].should == 5 } }
+
+      h = {:user => {:id => 5}}.with_indifferent_access
+      ['user', :user].each { |user| [:id, 'id'].each { |id| h[user][id].should == 5 } }
+    end
+  end
+  
+  describe "dup" do
+    it "should preserve default value" do
+      h = HashWithIndifferentAccess.new
+      h.default = '1234'
+      h.dup.default.should == h.default
+    end
+
+    it "should preserve class for subclasses" do
+      h = IndifferentHash.new
+      h.dup.class.should == h.class
+    end
+  end
+  
+  describe "deep_merge" do
+    it "should deep merge" do
+      hash_1 = HashWithIndifferentAccess.new({ :a => "a", :b => "b", :c => { :c1 => "c1", :c2 => "c2", :c3 => { :d1 => "d1" } } })
+      hash_2 = HashWithIndifferentAccess.new({ :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } })
+      hash_3 = { :a => 1, :c => { :c1 => 2, :c3 => { :d2 => "d2" } } }
+      expected = { "a" => 1, "b" => "b", "c" => { "c1" => 2, "c2" => "c2", "c3" => { "d1" => "d1", "d2" => "d2" } } }
+      hash_1.deep_merge(hash_2).should == expected
+      hash_1.deep_merge(hash_3).should == expected
+
+      hash_1.deep_merge!(hash_2)
+      hash_1.should == expected
+    end
+  end
+  
+  describe "slice" do
+    it "should slice with indiffent keys" do
+      original = { :a => 'x', :b => 'y', :c => 10 }.with_indifferent_access
+      expected = { :a => 'x', :b => 'y' }.with_indifferent_access
+
+      [['a', 'b'], [:a, :b]].each do |keys|
+        # Should return a new hash with only the given keys.
+        original.slice(*keys).should == expected
+        original.should.not == expected
+      end
+    end
+
+    it "should silce in place" do
+      original = { :a => 'x', :b => 'y', :c => 10 }.with_indifferent_access
+      expected = { :c => 10 }.with_indifferent_access
+
+      [['a', 'b'], [:a, :b]].each do |keys|
+        # Should replace the hash with only the given keys.
+        copy = original.dup
+        copy.slice!(*keys).should == expected
+      end
+    end
+
+    it "should slice sliced hash" do
+      original = {'login' => 'bender', 'password' => 'shiny', 'stuff' => 'foo'}
+      original = original.with_indifferent_access
+
+      slice = original.slice(:login, :password)
+
+      slice[:login].should == 'bender'
+      slice['login'].should == 'bender'
+    end
+  end
+  
+  describe "extract!" do
+    it "should extract values with indifferent keys" do
+      original = {:a => 1, 'b' => 2, :c => 3, 'd' => 4}.with_indifferent_access
+      expected = {:a => 1, :b => 2}.with_indifferent_access
+      remaining = {:c => 3, :d => 4}.with_indifferent_access
+
+      [['a', 'b'], [:a, :b]].each do |keys|
+        copy = original.dup
+        copy.extract!(*keys).should == expected
+        copy.should == remaining
+      end
+    end
+  end
+  
+  describe "default value" do
+    it "should use the default value for unknown key" do
+      hash_wia = HashWithIndifferentAccess.new(3)
+      hash_wia[:new_key].should == 3
+    end
+
+    it "should use default value if no key is supplied" do
+      hash_wia = HashWithIndifferentAccess.new(3)
+      hash_wia.default.should == 3
+    end
+
+    it "should nil if no default value is supplied" do
+      hash_wia = HashWithIndifferentAccess.new
+      hash_wia.default.should.be.nil
+    end
+    
+    it "should copy the default value when converting to hash with indifferent access" do
+      hash = Hash.new(3)
+      hash_wia = hash.with_indifferent_access
+      hash_wia.default.should == 3
+    end
+  end
+
+  describe "fetch" do
+    it "should fetch with indifferent access" do
+      @strings = @strings.with_indifferent_access
+
+      @strings.fetch('a').should == 1
+      @strings.fetch(:a.to_s).should == 1
+      @strings.fetch(:a).should == 1
+    end
+  end
+
+  describe "values_at" do
+    it "should return values for multiple keys" do
+      @strings = @strings.with_indifferent_access
+      @symbols = @symbols.with_indifferent_access
+      @mixed   = @mixed.with_indifferent_access
+  
+      @strings.values_at('a', 'b').should == [1, 2]
+      @strings.values_at(:a, :b).should == [1, 2]
+      @symbols.values_at('a', 'b').should == [1, 2]
+      @symbols.values_at(:a, :b).should == [1, 2]
+      @mixed.values_at('a', 'b').should == [1, 2]
+      @mixed.values_at(:a, :b).should == [1, 2]
+    end
+  end
+
+  describe "misc methods" do
+    it "should work as expected" do
+      @strings = @strings.with_indifferent_access
+      @symbols = @symbols.with_indifferent_access
+      @mixed   = @mixed.with_indifferent_access
+
+      hashes = { :@strings => @strings, :@symbols => @symbols, :@mixed => @mixed }
+      method_map = { :'[]' => 1, :fetch => 1, :values_at => [1],
+        :has_key? => true, :include? => true, :key? => true,
+        :member? => true }
+
+      hashes.each do |name, hash|
+        method_map.sort_by { |m| m.to_s }.each do |meth, expected|
+          hash.__send__(meth, 'a').should == expected
+          hash.__send__(meth, :a).should == expected
+        end
+      end
+    end
+  end
+end