chef 18.7.10 → 18.8.46

data/spec/unit/mixin/api_version_request_handling_spec.rb

@@ -1,126 +0,0 @@
-#
-# Author:: Tyler Cloke (tyler@chef.io)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-
-describe Chef::Mixin::ApiVersionRequestHandling do
-  let(:dummy_class) { Class.new { include Chef::Mixin::ApiVersionRequestHandling } }
-  let(:object) { dummy_class.new }
-
-  describe ".server_client_api_version_intersection" do
-    let(:default_supported_client_versions) { [0, 1, 2] }
-
-    context "when the response code is not 406" do
-      let(:response) { OpenStruct.new(code: "405") }
-      let(:exception) { Net::HTTPClientException.new("405 Something Else", response) }
-
-      it "returns nil" do
-        expect(object.server_client_api_version_intersection(exception, default_supported_client_versions))
-          .to be_nil
-      end
-
-    end # when the response code is not 406
-
-    context "when the response code is 406" do
-      let(:response) { OpenStruct.new(code: "406") }
-      let(:exception) { Net::HTTPClientException.new("406 Not Acceptable", response) }
-
-      context "when x-ops-server-api-version header does not exist" do
-        it "returns nil" do
-          expect(object.server_client_api_version_intersection(exception, default_supported_client_versions))
-            .to be_nil
-        end
-      end # when x-ops-server-api-version header does not exist
-
-      context "when x-ops-server-api-version header exists" do
-        let(:min_server_version) { 2 }
-        let(:max_server_version) { 4 }
-        let(:return_hash) do
-          {
-            "min_version" => min_server_version,
-            "max_version" => max_server_version,
-          }
-        end
-
-        before(:each) do
-          allow(response).to receive(:[]).with("x-ops-server-api-version").and_return(Chef::JSONCompat.to_json(return_hash))
-        end
-
-        context "when there is no intersection between client and server versions" do
-          shared_examples_for "no intersection between client and server versions" do
-            it "return an array" do
-              expect(object.server_client_api_version_intersection(exception, supported_client_versions))
-                .to be_a_kind_of(Array)
-            end
-
-            it "returns an empty array" do
-              expect(object.server_client_api_version_intersection(exception, supported_client_versions).length)
-                .to eq(0)
-            end
-
-          end
-
-          context "when all the versions are higher than the max" do
-            it_should_behave_like "no intersection between client and server versions" do
-              let(:supported_client_versions) { [5, 6, 7] }
-            end
-          end
-
-          context "when all the versions are lower than the min" do
-            it_should_behave_like "no intersection between client and server versions" do
-              let(:supported_client_versions) { [0, 1] }
-            end
-          end
-
-        end # when there is no intersection between client and server versions
-
-        context "when there is an intersection between client and server versions" do
-          context "when multiple versions intersect" do
-            let(:supported_client_versions) { [1, 2, 3, 4, 5] }
-
-            it "includes all of the intersection" do
-              expect(object.server_client_api_version_intersection(exception, supported_client_versions))
-                .to eq([2, 3, 4])
-            end
-          end # when multiple versions intersect
-
-          context "when only the min client version intersects" do
-            let(:supported_client_versions) { [0, 1, 2] }
-
-            it "includes the intersection" do
-              expect(object.server_client_api_version_intersection(exception, supported_client_versions))
-                .to eq([2])
-            end
-          end # when only the min client version intersects
-
-          context "when only the max client version intersects" do
-            let(:supported_client_versions) { [4, 5, 6] }
-
-            it "includes the intersection" do
-              expect(object.server_client_api_version_intersection(exception, supported_client_versions))
-                .to eq([4])
-            end
-          end # when only the max client version intersects
-
-        end # when there is an intersection between client and server versions
-
-      end # when x-ops-server-api-version header exists
-    end # when the response code is 406
-
-  end # .server_client_api_version_intersection
-end # Chef::Mixin::ApiVersionRequestHandling

data/spec/unit/mixin/checksum_spec.rb

@@ -1,82 +0,0 @@
-#
-# Author:: Adam Jacob (<adam@chef.io>)
-# Copyright:: Copyright (c) Chef Software Inc.
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-require "chef/mixin/checksum"
-require "stringio"
-
-class Chef::CMCCheck
-  include Chef::Mixin::Checksum
-end
-
-describe Chef::Mixin::Checksum do
-  before(:each) do
-    @checksum_user = Chef::CMCCheck.new
-    @cache = Chef::Digester.instance
-    @file = CHEF_SPEC_DATA + "/checksum/random.txt"
-    @stat = double("File::Stat", { mtime: Time.at(0) })
-    allow(File).to receive(:stat).and_return(@stat)
-  end
-
-  it "gets the checksum of a file" do
-    expect(@checksum_user.checksum(@file)).to eq("09ee9c8cc70501763563bcf9c218d71b2fbf4186bf8e1e0da07f0f42c80a3394")
-  end
-
-  describe "short_cksum" do
-    context "nil provided for checksum" do
-      it "returns none" do
-        expect(@checksum_user.short_cksum(nil)).to eq("none")
-      end
-    end
-
-    context "non-nil provided for checksum" do
-      it "returns the short checksum" do
-        expect(@checksum_user.short_cksum("u7ghbxikk3i9blsimmy2y2ionmxx")).to eq("u7ghbx")
-      end
-    end
-  end
-
-  describe "checksum_match?" do
-    context "when checksum cases match" do
-      it "returns true" do
-        expect(@checksum_user.checksum_match?("u7ghbxikk3i9blsimmy2y2ionmxx", "u7ghbxikk3i9blsimmy2y2ionmxx")).to be true
-      end
-    end
-
-    context "when one checksum is uppercase and other is lowercase" do
-      it "returns true" do
-        expect(@checksum_user.checksum_match?("U7GHBXIKK3I9BLSIMMY2Y2IONMXX", "u7ghbxikk3i9blsimmy2y2ionmxx")).to be true
-      end
-    end
-
-    context "when checksums do not match" do
-      it "returns false" do
-        expect(@checksum_user.checksum_match?("u7ghbxikk3i9blsimmy2y2ionmxx", "09ee9c8cc70501763563bcf9c218")).to be false
-      end
-    end
-
-    context "when checksum is nil" do
-      it "returns false" do
-        expect(@checksum_user.checksum_match?("u7ghbxikk3i9blsimmy2y2ionmxx", nil)).to be false
-        expect(@checksum_user.checksum_match?(nil, "09ee9c8cc70501763563bcf9c218")).to be false
-        expect(@checksum_user.checksum_match?(nil, nil)).to be false
-      end
-    end
-  end
-
-end

data/spec/unit/mixin/convert_to_class_name_spec.rb

@@ -1,54 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@kallistec.com>)
-# Copyright:: Copyright 2009-2016, Daniel DeLeo
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
-
-require "spec_helper"
-
-class ConvertToClassTestHarness
-  include Chef::Mixin::ConvertToClassName
-end
-
-describe Chef::Mixin::ConvertToClassName do
-
-  before do
-    @convert = ConvertToClassTestHarness.new
-  end
-
-  it "converts a_snake_case_word to a CamelCaseWord" do
-    expect(@convert.convert_to_class_name("now_camelized")).to eq("NowCamelized")
-  end
-
-  it "converts a CamelCaseWord to a snake_case_word" do
-    expect(@convert.convert_to_snake_case("NowImASnake")).to eq("now_im_a_snake")
-  end
-
-  it "removes the base classes before snake casing" do
-    expect(@convert.convert_to_snake_case("NameSpaced::Class::ThisIsWin", "NameSpaced::Class")).to eq("this_is_win")
-  end
-
-  it "removes the base classes without explicitly naming them and returns snake case" do
-    expect(@convert.snake_case_basename("NameSpaced::Class::ExtraWin")).to eq("extra_win")
-  end
-
-  it "interprets non-alphanumeric characters in snake case as word boundaries" do
-    expect(@convert.convert_to_class_name("now_camelized_without-hyphen")).to eq("NowCamelizedWithoutHyphen")
-  end
-
-  it "interprets underscore" do
-    expect(@convert.convert_to_class_name("_remove_leading_underscore")).to eq("RemoveLeadingUnderscore")
-  end
-end

data/spec/unit/mixin/deep_merge_spec.rb

@@ -1,357 +0,0 @@
-#
-# Author:: Matthew Kent (<mkent@magoazul.com>)
-# Author:: Steve Midgley (http://www.misuse.org/science)
-# Copyright:: Copyright 2010-2016, Matthew Kent
-# Copyright:: Copyright 2008-2016, Steve Midgley
-# License:: Apache License, Version 2.0
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#     http://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-
-# Notice:
-# This code is imported from deep_merge by Steve Midgley. deep_merge is
-# available under the MIT license from
-# http://trac.misuse.org/science/wiki/DeepMerge
-
-require "spec_helper"
-
-# Test coverage from the original author converted to rspec
-describe Chef::Mixin::DeepMerge, "deep_merge!" do
-  before do
-    @dm = Chef::Mixin::DeepMerge
-    @field_ko_prefix = "!merge"
-  end
-
-  # deep_merge core tests - moving from basic to more complex
-
-  it "tests merging an hash w/array into blank hash" do
-    hash_src = { "id" => "2" }
-    hash_dst = {}
-    @dm.deep_merge!(hash_src.dup, hash_dst)
-    expect(hash_dst).to eq(hash_src)
-  end
-
-  it "tests merging an hash w/array into blank hash" do
-    hash_src = { "region" => { "id" => %w{227 2} } }
-    hash_dst = {}
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq(hash_src)
-  end
-
-  it "tests merge from empty hash" do
-    hash_src = {}
-    hash_dst = { "property" => %w{2 4} }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => %w{2 4} })
-  end
-
-  it "tests merge to empty hash" do
-    hash_src = { "property" => %w{2 4} }
-    hash_dst = {}
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => %w{2 4} })
-  end
-
-  it "tests simple string overwrite" do
-    hash_src = { "name" => "value" }
-    hash_dst = { "name" => "value1" }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "name" => "value" })
-  end
-
-  it "tests simple string overwrite of empty hash" do
-    hash_src = { "name" => "value" }
-    hash_dst = {}
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq(hash_src)
-  end
-
-  it "tests hashes holding array" do
-    hash_src = { "property" => %w{1 3} }
-    hash_dst = { "property" => %w{2 4} }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => %w{2 4 1 3} })
-  end
-
-  it "tests hashes holding hashes holding arrays (array with duplicate elements is merged with dest then src" do
-    hash_src = { "property" => { "bedroom_count" => %w{1 2}, "bathroom_count" => ["1", "4+"] } }
-    hash_dst = { "property" => { "bedroom_count" => %w{3 2}, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => %w{3 2 1}, "bathroom_count" => ["2", "1", "4+"] } })
-  end
-
-  it "tests hash holding hash holding array v string (string is overwritten by array)" do
-    hash_src = { "property" => { "bedroom_count" => %w{1 2}, "bathroom_count" => ["1", "4+"] } }
-    hash_dst = { "property" => { "bedroom_count" => "3", "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => %w{1 2}, "bathroom_count" => ["2", "1", "4+"] } })
-  end
-
-  it "tests hash holding hash holding string v array (array is overwritten by string)" do
-    hash_src = { "property" => { "bedroom_count" => "3", "bathroom_count" => ["1", "4+"] } }
-    hash_dst = { "property" => { "bedroom_count" => %w{1 2}, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => "3", "bathroom_count" => ["2", "1", "4+"] } })
-  end
-
-  it "tests hash holding hash holding hash v array (array is overwritten by hash)" do
-    hash_src = { "property" => { "bedroom_count" => { "king_bed" => 3, "queen_bed" => 1 }, "bathroom_count" => ["1", "4+"] } }
-    hash_dst = { "property" => { "bedroom_count" => %w{1 2}, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => { "king_bed" => 3, "queen_bed" => 1 }, "bathroom_count" => ["2", "1", "4+"] } })
-  end
-
-  it "tests 3 hash layers holding integers (integers are overwritten by source)" do
-    hash_src = { "property" => { "bedroom_count" => { "king_bed" => 3, "queen_bed" => 1 }, "bathroom_count" => ["1", "4+"] } }
-    hash_dst = { "property" => { "bedroom_count" => { "king_bed" => 2, "queen_bed" => 4 }, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => { "king_bed" => 3, "queen_bed" => 1 }, "bathroom_count" => ["2", "1", "4+"] } })
-  end
-
-  it "tests 3 hash layers holding arrays of int (arrays are merged)" do
-    hash_src = { "property" => { "bedroom_count" => { "king_bed" => [3], "queen_bed" => [1] }, "bathroom_count" => ["1", "4+"] } }
-    hash_dst = { "property" => { "bedroom_count" => { "king_bed" => [2], "queen_bed" => [4] }, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => { "king_bed" => [2, 3], "queen_bed" => [4, 1] }, "bathroom_count" => ["2", "1", "4+"] } })
-  end
-
-  it "tests 1 hash overwriting 3 hash layers holding arrays of int" do
-    hash_src = { "property" => "1" }
-    hash_dst = { "property" => { "bedroom_count" => { "king_bed" => [2], "queen_bed" => [4] }, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => "1" })
-  end
-
-  it "tests 3 hash layers holding arrays of int (arrays are merged) but second hash's array is overwritten" do
-    hash_src = { "property" => { "bedroom_count" => { "king_bed" => [3], "queen_bed" => [1] }, "bathroom_count" => "1" } }
-    hash_dst = { "property" => { "bedroom_count" => { "king_bed" => [2], "queen_bed" => [4] }, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => { "king_bed" => [2, 3], "queen_bed" => [4, 1] }, "bathroom_count" => "1" } })
-  end
-
-  it "tests 3 hash layers holding arrays of int, but one holds int. This one overwrites, but the rest merge" do
-    hash_src = { "property" => { "bedroom_count" => { "king_bed" => 3, "queen_bed" => [1] }, "bathroom_count" => ["1"] } }
-    hash_dst = { "property" => { "bedroom_count" => { "king_bed" => [2], "queen_bed" => [4] }, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => { "king_bed" => 3, "queen_bed" => [4, 1] }, "bathroom_count" => %w{2 1} } })
-  end
-
-  it "tests 3 hash layers holding arrays of int, but source is incomplete." do
-    hash_src = { "property" => { "bedroom_count" => { "king_bed" => [3] }, "bathroom_count" => ["1"] } }
-    hash_dst = { "property" => { "bedroom_count" => { "king_bed" => [2], "queen_bed" => [4] }, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => { "king_bed" => [2, 3], "queen_bed" => [4] }, "bathroom_count" => %w{2 1} } })
-  end
-
-  it "tests 3 hash layers holding arrays of int, but source is shorter and has new 2nd level ints." do
-    hash_src = { "property" => { "bedroom_count" => { 2 => 3, "king_bed" => [3] }, "bathroom_count" => ["1"] } }
-    hash_dst = { "property" => { "bedroom_count" => { "king_bed" => [2], "queen_bed" => [4] }, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => { 2 => 3, "king_bed" => [2, 3], "queen_bed" => [4] }, "bathroom_count" => %w{2 1} } })
-  end
-
-  it "tests 3 hash layers holding arrays of int, but source is empty" do
-    hash_src = {}
-    hash_dst = { "property" => { "bedroom_count" => { "king_bed" => [2], "queen_bed" => [4] }, "bathroom_count" => ["2"] } }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => { "king_bed" => [2], "queen_bed" => [4] }, "bathroom_count" => ["2"] } })
-  end
-
-  it "tests 3 hash layers holding arrays of int, but dest is empty" do
-    hash_src = { "property" => { "bedroom_count" => { 2 => 3, "king_bed" => [3] }, "bathroom_count" => ["1"] } }
-    hash_dst = {}
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => { 2 => 3, "king_bed" => [3] }, "bathroom_count" => ["1"] } })
-  end
-
-  it "tests hash holding arrays of arrays" do
-    hash_src = { %w{1 2 3} => %w{1 2} }
-    hash_dst = { %w{4 5} => ["3"] }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ %w{1 2 3} => %w{1 2}, %w{4 5} => ["3"] })
-  end
-
-  it "tests merging of hash with blank hash, and make sure that source array split does not function when turned off" do
-    hash_src = { "property" => { "bedroom_count" => ["1", "2,3"] } }
-    hash_dst = {}
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "property" => { "bedroom_count" => ["1", "2,3"] } })
-  end
-
-  it "tests merging into a blank hash" do
-    hash_src = { "action" => "browse", "controller" => "results" }
-    hash_dst = {}
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq(hash_src)
-  end
-
-  it "tests are unmerged hashes passed unmodified w/out :unpack_arrays?" do
-    hash_src = { "amenity" => { "id" => ["26,27"] } }
-    hash_dst = {}
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "amenity" => { "id" => ["26,27"] } })
-  end
-
-  it "tests hash of array of hashes" do
-    hash_src = { "item" => [{ "1" => "3" }, { "2" => "4" }] }
-    hash_dst = { "item" => [{ "3" => "5" }] }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "item" => [{ "3" => "5" }, { "1" => "3" }, { "2" => "4" }] })
-  end
-
-  # Additions since import
-  it "should overwrite true with false when merging boolean values" do
-    hash_src = { "valid" => false }
-    hash_dst = { "valid" => true }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "valid" => false })
-  end
-
-  it "should overwrite false with true when merging boolean values" do
-    hash_src = { "valid" => true }
-    hash_dst = { "valid" => false }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "valid" => true })
-  end
-
-  it "should overwrite a string with an empty string when merging string values" do
-    hash_src = { "item" => " " }
-    hash_dst = { "item" => "orange" }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "item" => " " })
-  end
-
-  it "should overwrite an empty string with a string when merging string values" do
-    hash_src = { "item" => "orange" }
-    hash_dst = { "item" => " " }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "item" => "orange" })
-  end
-
-  it "should overwrite a string with a nil when merging nil values" do
-    hash_src = { "item" => nil }
-    hash_dst = { "item" => "orange" }
-    @dm.deep_merge!(hash_src, hash_dst)
-    expect(hash_dst).to eq({ "item" => nil })
-  end
-
-end # deep_merge!
-
-# Chef specific
-describe Chef::Mixin::DeepMerge do
-  before do
-    @dm = Chef::Mixin::DeepMerge
-  end
-
-  describe "merge" do
-    it "should merge a hash into an empty hash" do
-      hash_dst = {}
-      hash_src = { "id" => "2" }
-      expect(@dm.merge(hash_dst, hash_src)).to eq(hash_src)
-    end
-
-    it "should merge a nested hash into an empty hash" do
-      hash_dst = {}
-      hash_src = { "region" => { "id" => %w{227 2} } }
-      expect(@dm.merge(hash_dst, hash_src)).to eq(hash_src)
-    end
-
-    it "should overwrite as string value when merging hashes" do
-      hash_dst = { "name" => "value1" }
-      hash_src = { "name" => "value" }
-      expect(@dm.merge(hash_dst, hash_src)).to eq({ "name" => "value" })
-    end
-
-    it "should merge arrays within hashes" do
-      hash_dst = { "property" => %w{2 4} }
-      hash_src = { "property" => %w{1 3} }
-      expect(@dm.merge(hash_dst, hash_src)).to eq({ "property" => %w{2 4 1 3} })
-    end
-
-    it "should merge deeply nested hashes" do
-      hash_dst = { "property" => { "values" => { "are" => "falling", "can" => "change" } } }
-      hash_src = { "property" => { "values" => { "are" => "stable", "may" => "rise" } } }
-      expect(@dm.merge(hash_dst, hash_src)).to eq({ "property" => { "values" => { "are" => "stable", "can" => "change", "may" => "rise" } } })
-    end
-
-    it "should not modify the source or destination during the merge" do
-      hash_dst = { "property" => %w{1 2 3} }
-      hash_src = { "property" => %w{4 5 6} }
-      ret = @dm.merge(hash_dst, hash_src)
-      expect(hash_dst).to eq({ "property" => %w{1 2 3} })
-      expect(hash_src).to eq({ "property" => %w{4 5 6} })
-      expect(ret).to eq({ "property" => %w{1 2 3 4 5 6} })
-    end
-
-    it "should not error merging un-dupable objects" do
-      @dm.deep_merge(nil, 4)
-    end
-
-  end
-
-  describe "hash-only merging" do
-    it "merges Hashes like normal deep merge" do
-      merge_ee_hash = { "top_level_a" => { "1_deep_a" => "1-a-merge-ee", "1_deep_b" => "1-deep-b-merge-ee" }, "top_level_b" => "top-level-b-merge-ee" }
-      merge_with_hash = { "top_level_a" => { "1_deep_b" => "1-deep-b-merged-onto", "1_deep_c" => "1-deep-c-merged-onto" }, "top_level_b" => "top-level-b-merged-onto" }
-
-      merged_result = @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
-
-      expect(merged_result["top_level_b"]).to eq("top-level-b-merged-onto")
-      expect(merged_result["top_level_a"]["1_deep_a"]).to eq("1-a-merge-ee")
-      expect(merged_result["top_level_a"]["1_deep_b"]).to eq("1-deep-b-merged-onto")
-      expect(merged_result["top_level_a"]["1_deep_c"]).to eq("1-deep-c-merged-onto")
-    end
-
-    it "replaces arrays rather than merging them" do
-      merge_ee_hash = { "top_level_a" => { "1_deep_a" => "1-a-merge-ee", "1_deep_b" => %w{A A A} }, "top_level_b" => "top-level-b-merge-ee" }
-      merge_with_hash = { "top_level_a" => { "1_deep_b" => %w{B B B}, "1_deep_c" => "1-deep-c-merged-onto" }, "top_level_b" => "top-level-b-merged-onto" }
-
-      merged_result = @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
-
-      expect(merged_result["top_level_b"]).to eq("top-level-b-merged-onto")
-      expect(merged_result["top_level_a"]["1_deep_a"]).to eq("1-a-merge-ee")
-      expect(merged_result["top_level_a"]["1_deep_b"]).to eq(%w{B B B})
-    end
-
-    it "replaces non-hash items with hashes when there's a conflict" do
-      merge_ee_hash = { "top_level_a" => "top-level-a-mergee", "top_level_b" => "top-level-b-merge-ee" }
-      merge_with_hash = { "top_level_a" => { "1_deep_b" => %w{B B B}, "1_deep_c" => "1-deep-c-merged-onto" }, "top_level_b" => "top-level-b-merged-onto" }
-
-      merged_result = @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
-
-      expect(merged_result["top_level_a"]).to be_a(Hash)
-      expect(merged_result["top_level_a"]["1_deep_a"]).to be_nil
-      expect(merged_result["top_level_a"]["1_deep_b"]).to eq(%w{B B B})
-    end
-
-    it "does not mutate deeply-nested original hashes by default" do
-      merge_ee_hash =   { "top_level_a" => { "1_deep_a" => { "2_deep_a" => { "3_deep_a" => "foo" } } } }
-      merge_with_hash = { "top_level_a" => { "1_deep_a" => { "2_deep_a" => { "3_deep_b" => "bar" } } } }
-      @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
-      expect(merge_ee_hash).to eq({ "top_level_a" => { "1_deep_a" => { "2_deep_a" => { "3_deep_a" => "foo" } } } })
-      expect(merge_with_hash).to eq({ "top_level_a" => { "1_deep_a" => { "2_deep_a" => { "3_deep_b" => "bar" } } } })
-    end
-
-    it "does not error merging un-dupable items" do
-      merge_ee_hash = { "top_level_a" => 1, "top_level_b" => false }
-      merge_with_hash = { "top_level_a" => 2, "top_level_b" => true }
-      @dm.hash_only_merge(merge_ee_hash, merge_with_hash)
-    end
-
-    it "should overwrite a string with a nil when merging nil values" do
-      hash_src = { "item" => nil }
-      hash_dst = { "item" => "orange" }
-      merged_result = @dm.hash_only_merge(hash_dst, hash_src)
-      expect(merged_result).to eq({ "item" => nil })
-    end
-  end
-end