configliere 0.3.4 → 0.4.4

data/spec/configliere/config_block_spec.rb

@@ -15,11 +15,20 @@ describe "Configliere::ConfigBlock" do
       @config.resolve!
     end
     it 'resolves blocks last' do
-      Configliere.use :config_block, :define, :encrypted
+      Configliere.use :config_block, :encrypted
       @config.should_receive(:resolve_types!).ordered
       @config.should_receive(:resolve_finally_blocks!).ordered
       @config.resolve!
     end
+
+    describe '#resolve!' do
+      it 'calls super and returns self' do
+        Configliere::ParamParent.class_eval do def resolve!() dummy ; end ; end
+        @config.should_receive(:dummy)
+        @config.resolve!.should equal(@config)
+        Configliere::ParamParent.class_eval do def resolve!() self ; end ; end
+      end
+    end
   end
 
 end

data/spec/configliere/config_file_spec.rb

@@ -1,90 +1,118 @@
 require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-Configliere.use :config_file
 
-describe "Configliere::ConfigFile" do
+describe Configliere::ConfigFile do
   before do
-    @config = Configliere.new :my_param => 'val'
+    @config = Configliere::Param.new :my_param => 'default_val', :also_a_param => true
     FileUtils.stub! :mkdir_p
   end
 
-  describe 'loads a config file' do
+  it 'is used by default' do
+    @config.should respond_to(:read)
+  end
+
+  describe 'loading a config file' do
     before do
-      @config = Configliere::Param.new :my_param => 'val'
-      @fake_file = '{ :my_param: val }'
+      @fake_file = '{ :my_param: val_from_file }'
     end
+
     describe 'successfully' do
-      it 'loads a symbol name from the default config file' do
-        File.should_receive(:open).with(Configliere::DEFAULT_CONFIG_FILE).and_return(':my_settings: ' + @fake_file)
-        @config.read :my_settings
-      end
-      it 'loads an absolute pathname from the given file' do
+      it 'with an absolute pathname uses it directly' do
         File.should_receive(:open).with('/fake/path.yaml').and_return(@fake_file)
         @config.read '/fake/path.yaml'
       end
-      it 'loads a simple filename from the default config dir' do
+      it 'with a simple filename, references it to the default config dir' do
         File.should_receive(:open).with(Configliere::DEFAULT_CONFIG_DIR + '/file.yaml').and_return(@fake_file)
         @config.read 'file.yaml'
       end
-      it 'loads an absolute pathname from the given file' do
-        File.should_receive(:open).with('/fake/path.yaml').and_return(@fake_file)
-        @config.read '/fake/path.yaml'
+      it 'returns the config object for chaining' do
+        File.should_receive(:open).with(Configliere::DEFAULT_CONFIG_DIR + '/file.yaml').and_return(@fake_file)
+        @config.defaults :also_a_param => true
+        @config.read('file.yaml').should == { :my_param => 'val_from_file', :also_a_param => true }
       end
       after do
-        @config[:my_param].should == 'val'
+        @config[:my_param].should == 'val_from_file'
       end
     end
-    describe 'in edge cases' do
-      it 'handles a file not found' do
-        @config = Configliere::Param.new
-        File.stub(:open).and_raise(Errno::ENOENT)
-        @config.read('nonexistent_file.yaml').should == {}
-      end
+
+    it 'no longer provides a default config file' do
+      lambda{ @config.read(:my_settings) }.should raise_error(Configliere::DeprecatedError)
+      defined?(Configliere::DEFAULT_CONFIG_FILE).should_not be_true
     end
-  end
 
-  describe 'saves to a config file' do
-    describe 'successfully' do
-      it 'saves a symbol name to the default config file' do
-        Configliere::ConfigFile.should_receive(:merge_into_yaml_file).
-          with(Configliere::DEFAULT_CONFIG_FILE, :my_settings, { :my_param => 'val'})
-        @config.save! :my_settings
+    it 'warns but does not fail if the file is missing' do
+      @config = Configliere::Param.new
+      File.stub(:open).and_raise(Errno::ENOENT)
+      @config.should_receive(:warn).with("Loading empty configliere settings file #{Configliere::DEFAULT_CONFIG_DIR}/nonexistent_file.yaml")
+      @config.read('nonexistent_file.yaml').should == {}
+    end
+
+
+    describe 'with an environment scope' do
+      before do
+        @config.defaults :reload => :unset
+        @hash_with_subenvs = { :development => { :reload => true }, :production => { :reload => false }}
+        File.stub :open
+        YAML.should_receive(:load).and_return(@hash_with_subenvs)
       end
-      it 'saves a pathname to the given file' do
-        fake_file = StringIO.new('', 'w')
-        File.should_receive(:open).with('/fake/path.yaml', 'w').and_yield(fake_file)
-        fake_file.should_receive(:<<).with("--- \n:my_param: val\n")
-        @config.save! '/fake/path.yaml'
+
+      it 'slices out a subhash given by :env' do
+        @config.read('f', :env => :development)
+        @config.should == { :reload => true, :my_param => 'default_val', :also_a_param => true }
+      end
+
+      it 'slices out a different subhash with a different :env' do
+        @config.read('f', :env => :production)
+        @config.should == { :reload => false, :my_param => 'default_val', :also_a_param => true }
+      end
+
+      it 'does no slicing without the :env option' do
+        @config.read('f')
+        @config.should == { :development => { :reload => true }, :production => { :reload => false }, :reload => :unset, :my_param => 'default_val', :also_a_param => true }
+      end
+
+      it 'has no effect if the key given by :env option is absent' do
+        @config.read('f', :env => :foobar)
+        @config.should == { :reload => :unset, :my_param => 'default_val', :also_a_param => true }
       end
-      it 'ensures the directory exists' do
-        fake_file = StringIO.new('', 'w')
-        File.stub!(:open).with('/fake/path.yaml', 'w').and_yield(fake_file)
-        FileUtils.should_receive(:mkdir_p).with('/fake')
-        @config.save! '/fake/path.yaml'
+
+      it 'does not type convert the :env option' do
+        @hash_with_subenvs['john_woo'] = { :reload => :sideways }
+        @config.read('f', :env => 'john_woo')
+        @config.should == { :reload => :sideways, :my_param => 'default_val', :also_a_param => true }
       end
     end
   end
 
-  describe 'merge_into_yaml_file' do
-    it 'merges, leaving existing values put' do
-      fake_file = StringIO.new(":my_settings: { :my_param: orig_val }\n:other_settings: { :that_param: other_val }", 'r+')
-      File.should_receive(:open).with('/fake/path.yaml').and_return(fake_file)
+
+  describe 'saves to a config file' do
+    it 'with an absolute pathname, as given' do
+      fake_file = StringIO.new('', 'w')
       File.should_receive(:open).with('/fake/path.yaml', 'w').and_yield(fake_file)
-      mock_dump = 'mock_dump'
-      YAML.should_receive(:dump).with({ :my_settings => { :my_param => 'new_val'}, :other_settings => { :that_param => 'other_val'}}).and_return(mock_dump)
-      fake_file.should_receive(:<<).with(mock_dump)
-      Configliere::ConfigFile.merge_into_yaml_file '/fake/path.yaml', :my_settings, :my_param => 'new_val'
+      fake_file.should_receive(:<<).with("--- \n:my_param: default_val\n:also_a_param: true\n")
+      @config.save! '/fake/path.yaml'
     end
-  end
 
-  describe 'maps handles to filenames' do
-    it 'loads a symbol name from the default config file' do
-      @config.send(:filename_for_handle, :my_settings).should == Configliere::DEFAULT_CONFIG_FILE
+    it 'with a simple pathname, in the default config dir' do
+      fake_file = StringIO.new('', 'w')
+      File.should_receive(:open).with(Configliere::DEFAULT_CONFIG_DIR + '/file.yaml', 'w').and_yield(fake_file)
+      fake_file.should_receive(:<<).with("--- \n:my_param: default_val\n:also_a_param: true\n")
+      @config.save! 'file.yaml'
     end
-    it 'loads an absolute pathname from the given file' do
-      @config.send(:filename_for_handle, '/fake/path.yaml').should == '/fake/path.yaml'
+
+    it 'and ensures the directory exists' do
+      fake_file = StringIO.new('', 'w')
+      File.stub!(:open).with('/fake/path.yaml', 'w').and_yield(fake_file)
+      FileUtils.should_receive(:mkdir_p).with('/fake')
+      @config.save! '/fake/path.yaml'
     end
-    it 'loads a simple filename from the default config dir' do
-      @config.send(:filename_for_handle, 'file.yaml').should == Configliere::DEFAULT_CONFIG_DIR + '/file.yaml'
+  end
+
+  describe '#resolve!' do
+    it 'calls super and returns self' do
+      Configliere::ParamParent.class_eval do def resolve!() dummy ; end ; end
+      @config.should_receive(:dummy)
+      @config.resolve!.should equal(@config)
+      Configliere::ParamParent.class_eval do def resolve!() self ; end ; end
     end
   end
 

data/spec/configliere/crypter_spec.rb

@@ -3,12 +3,13 @@ require 'configliere/crypter'
 include Configliere
 
 describe "Crypter" do
-  ENCRYPTED_FOO_VAL = "q\317\201\247\230\314P\021\305\n\363\315d\207\345y\346\255\a\202\006i\245\343T\203e\327a\316\245\313"
+  ENCRYPTED_FOO_VAL = "cc+Bp5jMUBHFCvPNZIfleeatB4IGaaXjVINl12HOpcs=\n"
+  FOO_VAL_IV = Base64.decode64(ENCRYPTED_FOO_VAL)[0..15]
   it "encrypts" do
     # Force the same initialization vector as used to prepare the test value
     @cipher = Crypter.send(:new_cipher, :encrypt, 'sekrit')
     Crypter.should_receive(:new_cipher).and_return(@cipher)
-    @cipher.should_receive(:random_iv).and_return ENCRYPTED_FOO_VAL[0..15]
+    @cipher.should_receive(:random_iv).and_return FOO_VAL_IV
     # OK so do the test now.
     Crypter.encrypt('foo_val', 'sekrit').should == ENCRYPTED_FOO_VAL
   end

data/spec/configliere/deep_hash_spec.rb

@@ -0,0 +1,401 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+class AwesomeHash < DeepHash ; end
+
+describe DeepHash do
+  before(:each) do
+    @deep_hash = DeepHash.new.merge!({ :nested_1 => { :nested_2 => { :leaf_3 => "val3" }, :leaf_2 => "val2" }, :leaf_at_top => 'val1b' })
+    @hash = { "str_key" => "strk_val", :sym_key => "symk_val"}
+    @sub  = AwesomeHash.new("str_key" => "strk_val", :sym_key => "symk_val")
+  end
+
+  describe "#initialize" do
+    it 'adopts a Hash when given' do
+      deep_hash = DeepHash.new(@hash)
+      @hash.each{|k,v| deep_hash[k].should == v }
+      deep_hash.keys.any?{|key| key.is_a?(String) }.should be_false
+    end
+
+    it 'converts all pure Hash values into DeepHashes if param is a Hash' do
+      deep_hash = DeepHash.new :sym_key => @hash
+      deep_hash[:sym_key].should be_an_instance_of(DeepHash)
+      # sanity check
+      deep_hash[:sym_key][:sym_key].should == "symk_val"
+    end
+
+    it 'does not convert Hash subclass values into DeepHashes' do
+      deep_hash = DeepHash.new :sub => @sub
+      deep_hash[:sub].should be_an_instance_of(AwesomeHash)
+    end
+
+    it 'converts all value items if value is an Array' do
+      deep_hash = DeepHash.new :arry => { :sym_key => [@hash] }
+      deep_hash[:arry].should be_an_instance_of(DeepHash)
+      # sanity check
+      deep_hash[:arry][:sym_key].first[:sym_key].should == "symk_val"
+    end
+
+    it 'delegates to superclass constructor if param is not a Hash' do
+      deep_hash = DeepHash.new("dash berlin")
+
+      deep_hash["unexisting key"].should == "dash berlin"
+    end
+  end # describe "#initialize"
+
+  describe "#update" do
+    it 'converts all keys into symbols when param is a Hash' do
+      deep_hash = DeepHash.new(@hash)
+      deep_hash.update("starry" => "night")
+
+      deep_hash.keys.any?{|key| key.is_a?(String) }.should be_false
+    end
+
+    it 'converts all Hash values into DeepHashes if param is a Hash' do
+      deep_hash = DeepHash.new :hash => @hash
+      deep_hash.update(:hash => { :sym_key => "is buggy in Ruby 1.8.6" })
+
+      deep_hash[:hash].should be_an_instance_of(DeepHash)
+    end
+  end # describe "#update"
+
+  describe '#[]=' do
+    it 'symbolizes keys' do
+      @deep_hash['leaf_at_top'] = :fedora
+      @deep_hash['new']         = :unseen
+      @deep_hash.should == {:nested_1 => {:nested_2 => {:leaf_3 => "val3"}, :leaf_2 => "val2"}, :leaf_at_top => :fedora, :new => :unseen}
+    end
+    it 'deep-sets dotted vals, replacing values' do
+      @deep_hash['moon.man'] = :cheesy
+      @deep_hash[:moon][:man].should == :cheesy
+    end
+    it 'deep-sets dotted vals, creating new values' do
+      @deep_hash['moon.cheese.type'] = :tilsit
+      @deep_hash[:moon][:cheese][:type].should == :tilsit
+    end
+    it 'deep-sets dotted vals, auto-vivifying intermediate hashes' do
+      @deep_hash['this.that.the_other'] = :fuhgeddaboudit
+      @deep_hash[:this][:that][:the_other].should == :fuhgeddaboudit
+    end
+    it 'converts all Hash value into DeepHash' do
+      deep_hash = DeepHash.new :hash => @hash
+      deep_hash[:hash] = { :sym_key => "is buggy in Ruby 1.8.6" }
+      deep_hash[:hash].should be_an_instance_of(DeepHash)
+    end
+  end
+
+  describe '#[]' do
+    it 'deep-gets dotted vals' do
+      hsh = { :hat => :cat, :basket => :lotion, :moon => { :man => :smiling, :cheese => {:type => :tilsit} } }
+      @deep_hash = Configliere::Param.new hsh.dup
+      @deep_hash['moon.man'].should == :smiling
+      @deep_hash['moon.cheese.type'].should == :tilsit
+      @deep_hash['moon.cheese.smell'].should be_nil
+      @deep_hash['moon.non.existent.interim.values'].should be_nil
+      @deep_hash['moon.non'].should be_nil
+      if (RUBY_VERSION >= '1.9') then lambda{ @deep_hash['hat.cat'] }.should raise_error(TypeError)
+      else                            lambda{ @deep_hash['hat.cat'] }.should raise_error(NoMethodError, 'undefined method `[]\' for :cat:Symbol') end
+      @deep_hash.should == hsh # shouldn't change from reading (specifically, shouldn't autovivify)
+    end
+  end
+
+  def arrays_should_be_equal arr1, arr2
+    arr1.sort_by{|s| s.to_s }.should == arr2.sort_by{|s| s.to_s }
+  end
+
+  describe "#to_hash" do
+    it 'returns instance of Hash' do
+      DeepHash.new(@hash).to_hash.should be_an_instance_of(Hash)
+    end
+
+    it 'preserves keys' do
+      deep_hash = DeepHash.new(@hash)
+      converted  = deep_hash.to_hash
+      arrays_should_be_equal deep_hash.keys, converted.keys
+    end
+
+    it 'preserves value' do
+      deep_hash = DeepHash.new(@hash)
+      converted = deep_hash.to_hash
+      arrays_should_be_equal deep_hash.values, converted.values
+    end
+  end
+
+  describe '#compact' do
+    it 'removes nils but not empties or falsehoods' do
+      DeepHash.new({ 1 => nil }).compact.should == {}
+      DeepHash.new({ 1 => nil, 2 => false, 3 => {}, 4 => "", :remains => true }).compact!.should == { 2 => false, 3 => {}, 4 => "", :remains => true }
+    end
+
+    it 'leaves original alone' do
+      deep_hash = DeepHash.new({ 1 => nil, :remains => true })
+      deep_hash.compact.should == { :remains => true }
+      deep_hash.should == { 1 => nil, :remains => true }
+    end
+  end
+
+  describe '#compact!' do
+    it 'removes nils but not empties or falsehoods' do
+      DeepHash.new({ 1 => nil}).compact!.should == {}
+      DeepHash.new({ 1 => nil, 2 => false, 3 => {}, 4 => "", :remains => true }).compact!.should == { 2 => false, 3 => {}, 4 => "", :remains => true }
+    end
+
+    it 'modifies in-place' do
+      deep_hash = DeepHash.new({ 1 => nil, :remains => true })
+      deep_hash.compact!.should == { :remains => true }
+      deep_hash.should == { :remains => true }
+    end
+  end
+
+  describe '#slice' do
+    before do
+      @deep_hash = DeepHash.new({ :a => 'x', :b => 'y', :c => 10 })
+    end
+
+    it 'returns a new hash with only the given keys' do
+      @deep_hash.slice(:a, :b).should == { :a => 'x', :b => 'y' }
+      @deep_hash.should == { :a => 'x', :b => 'y', :c => 10 }
+    end
+
+    it 'with bang replaces the hash with only the given keys' do
+      @deep_hash.slice!(:a, :b).should == { :c => 10 }
+      @deep_hash.should == { :a => 'x', :b => 'y' }
+    end
+
+    it 'ignores an array key' do
+      @deep_hash.slice([:a, :b], :c).should == { :c => 10 }
+      @deep_hash.should == { :a => 'x', :b => 'y', :c => 10 }
+    end
+
+    it 'with bang ignores an array key' do
+      @deep_hash.slice!([:a, :b], :c).should == { :a => 'x', :b => 'y' }
+      @deep_hash.should == { :c => 10 }
+    end
+
+    it 'uses splatted keys individually' do
+      @deep_hash.slice(*[:a, :b]).should == { :a => 'x', :b => 'y' }
+      @deep_hash.should == { :a => 'x', :b => 'y', :c => 10 }
+    end
+
+    it 'with bank uses splatted keys individually' do
+      @deep_hash.slice!(*[:a, :b]).should == { :c => 10 }
+      @deep_hash.should == { :a => 'x', :b => 'y' }
+    end
+  end
+
+  describe '#extract' do
+    before do
+      @deep_hash = DeepHash.new({ :a => 'x', :b => 'y', :c => 10 })
+    end
+
+    it 'replaces the hash with only the given keys' do
+      @deep_hash.extract!(:a, :b).should == { :a => 'x', :b => 'y' }
+      @deep_hash.should == { :c => 10 }
+    end
+
+    it 'leaves the hash empty if all keys are gone' do
+      @deep_hash.extract!(:a, :b, :c).should == { :a => 'x', :b => 'y', :c => 10 }
+      @deep_hash.should == {}
+    end
+
+    it 'gets values for all given keys even if missing' do
+      @deep_hash.extract!(:bob, :c).should == { :bob => nil, :c => 10 }
+      @deep_hash.should == { :a => 'x', :b => 'y' }
+    end
+
+    it 'is OK when empty' do
+      DeepHash.new.slice!(:a, :b, :c).should == {}
+    end
+
+    it 'returns an instance of the same class' do
+      @deep_hash.slice(:a).should be_a(DeepHash)
+    end
+  end
+
+  describe 'assert_valid_keys' do
+    before do
+      @deep_hash = DeepHash.new({ :failure => "stuff", :funny => "business" })
+    end
+
+    it 'is true and does not raise when valid' do
+      @deep_hash.assert_valid_keys([ :failure, :funny ]).should be_nil
+      @deep_hash.assert_valid_keys(:failure, :funny).should be_nil
+    end
+
+    it 'fails when invalid' do
+      @deep_hash[:failore] = @deep_hash.delete(:failure)
+      lambda{ @deep_hash.assert_valid_keys([ :failure, :funny ]) }.should raise_error(ArgumentError, "Unknown key(s): failore")
+      lambda{ @deep_hash.assert_valid_keys(:failure, :funny)     }.should raise_error(ArgumentError, "Unknown key(s): failore")
+    end
+  end
+
+  describe "#delete" do
+    it 'converts Symbol key into String before deleting' do
+      deep_hash = DeepHash.new(@hash)
+
+      deep_hash.delete(:sym_key)
+      deep_hash.key?("hash").should be_false
+    end
+
+    it 'works with String keys as well' do
+      deep_hash = DeepHash.new(@hash)
+
+      deep_hash.delete("str_key")
+      deep_hash.key?("str_key").should be_false
+    end
+  end
+
+  describe "#merge" do
+    before(:each) do
+      @deep_hash = DeepHash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'returns instance of DeepHash' do
+      @deep_hash.should be_an_instance_of(DeepHash)
+    end
+
+    it 'merges in give Hash' do
+      @deep_hash["no"].should == "in between"
+    end
+  end
+
+  describe "#fetch" do
+    before(:each) do
+      @deep_hash = DeepHash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'converts key before fetching' do
+      @deep_hash.fetch("no").should == "in between"
+    end
+
+    it 'returns alternative value if key lookup fails' do
+      @deep_hash.fetch("flying", "screwdriver").should == "screwdriver"
+    end
+  end
+
+
+  describe "#values_at" do
+    before(:each) do
+      @deep_hash = DeepHash.new(@hash).merge(:no => "in between")
+    end
+
+    it 'is indifferent to whether keys are strings or symbols' do
+      @deep_hash.values_at("sym_key", :str_key, :no).should == ["symk_val", "strk_val", "in between"]
+    end
+  end
+
+  describe "#symbolize_keys" do
+    it 'with bang returns the deep_hash itself' do
+      deep_hash = DeepHash.new(@hash)
+      deep_hash.symbolize_keys!.object_id.should == deep_hash.object_id
+    end
+
+    it 'returns a dup of itself' do
+      deep_hash = DeepHash.new(@hash)
+      deep_hash.symbolize_keys.should == deep_hash
+    end
+  end
+
+  describe "#reverse_merge" do
+    before do
+      @defaults  = { :a => "x", :b => "y", :c => 10 }.freeze
+      @deep_hash = DeepHash.new({ :a => 1, :b => 2 })
+    end
+
+    it 'merges defaults into options, creating a new hash' do
+      @deep_hash.reverse_merge(@defaults).should == { :a => 1, :b => 2, :c => 10 }
+      @deep_hash.should == { :a => 1, :b => 2 }
+    end
+
+    it 'with bang merges! defaults into options, replacing options' do
+      @deep_hash.reverse_merge!(@defaults).should == { :a => 1, :b => 2, :c => 10 }
+      @deep_hash.should == { :a => 1, :b => 2, :c => 10 }
+    end
+  end
+
+  describe "#deep_merge!" do
+    it "merges two subhashes when they share a key" do
+      @deep_hash.deep_merge!(:nested_1 => { :nested_2  => { :leaf_3_also  => "val3a" } })
+      @deep_hash.should == { :nested_1 => { :nested_2  => { :leaf_3_also  => "val3a", :leaf_3 => "val3" }, :leaf_2 => "val2" }, :leaf_at_top => 'val1b' }
+    end
+    it "merges two subhashes when they share a symbolized key" do
+      @deep_hash.deep_merge!(:nested_1 => { "nested_2" => { "leaf_3_also" => "val3a" } })
+      @deep_hash.should == { :nested_1 => { :nested_2  => { :leaf_3_also  => "val3a", :leaf_3 => "val3" }, :leaf_2 => "val2" }, :leaf_at_top => "val1b" }
+    end
+    it "preserves values in the original" do
+      @deep_hash.deep_merge! :other_key => "other_val"
+      @deep_hash[:nested_1][:leaf_2].should == "val2"
+      @deep_hash[:other_key].should == "other_val"
+    end
+    # it "converts all Hash values into DeepHashes if param is a Hash"  do
+    #   @deep_hash.deep_merge!({:nested_1 => { :nested_2 => { :leaf_3_also => "val3a" } }, :other1 => { "other2" => "other_val2" }})
+    #   @deep_hash[:nested_1].should be_an_instance_of(DeepHash)
+    #   @deep_hash[:nested_1][:nested_2].should be_an_instance_of(DeepHash)
+    #   @deep_hash[:other1].should be_an_instance_of(DeepHash)
+    # end
+    it "replaces values from the given DeepHash" do
+      @deep_hash.deep_merge!(:nested_1 => { :nested_2 => { :leaf_3 => "new_val3" }, :leaf_2 => { "other2" => "other_val2" }})
+      @deep_hash[:nested_1][:nested_2][:leaf_3].should == 'new_val3'
+      @deep_hash[:nested_1][:leaf_2].should == { :other2 => "other_val2" }
+    end
+
+    it "replaces values from the given DeepHash" do
+      @deep_hash.deep_merge!(:nested_1 => { :nested_2 => { :leaf_3 => [] }, :leaf_2 => nil }, :leaf_at_top => '')
+      @deep_hash[:nested_1][:nested_2][:leaf_3].should == []
+      @deep_hash[:nested_1][:leaf_2].should == "val2"
+      @deep_hash[:leaf_at_top].should == ""
+    end
+  end
+
+  describe "#deep_set" do
+    it 'should set a new value (single arg)' do
+      @deep_hash.deep_set :new_key, 'new_val'
+      @deep_hash[:new_key].should == 'new_val'
+    end
+    it 'should set a new value (multiple args)' do
+      @deep_hash.deep_set :nested_1, :nested_2, :new_key, 'new_val'
+      @deep_hash[:nested_1][:nested_2][:new_key].should == 'new_val'
+    end
+    it 'should replace an existing value (single arg)' do
+      @deep_hash.deep_set :leaf_at_top, 'new_val'
+      @deep_hash[:leaf_at_top].should == 'new_val'
+    end
+    it 'should replace an existing value (multiple args)' do
+      @deep_hash.deep_set :nested_1, :nested_2, 'new_val'
+      @deep_hash[:nested_1][:nested_2].should == 'new_val'
+    end
+    it 'should auto-vivify intermediate hashes' do
+      @deep_hash.deep_set :one, :two, :three, :four, 'new_val'
+      @deep_hash[:one][:two][:three][:four].should == 'new_val'
+    end
+  end
+
+  describe "#deep_delete" do
+    it 'should remove the key from the array (multiple args)' do
+      @deep_hash.deep_delete(:nested_1)
+      @deep_hash[:nested_1].should be_nil
+      @deep_hash.should == { :leaf_at_top => 'val1b'}
+    end
+    it 'should remove the key from the array (multiple args)' do
+      @deep_hash.deep_delete(:nested_1, :nested_2, :leaf_3)
+      @deep_hash[:nested_1][:nested_2][:leaf_3].should be_nil
+      @deep_hash.should == {:leaf_at_top => "val1b", :nested_1 => {:leaf_2 => "val2", :nested_2 => {}}}
+    end
+    it 'should return the value if present (single args)' do
+      returned_val = @deep_hash.deep_delete(:leaf_at_top)
+      returned_val.should == 'val1b'
+    end
+    it 'should return the value if present (multiple args)' do
+      returned_val = @deep_hash.deep_delete(:nested_1, :nested_2, :leaf_3)
+      returned_val.should == 'val3'
+    end
+    it 'should return nil if the key is absent (single arg)' do
+      returned_val = @deep_hash.deep_delete(:nested_1, :nested_2, :missing_key)
+      returned_val.should be_nil
+    end
+    it 'should return nil if the key is absent (multiple args)' do
+      returned_val = @deep_hash.deep_delete(:missing_key)
+      returned_val.should be_nil
+    end
+  end
+
+end