chef 18.8.11 → 18.8.54

data/spec/unit/chef_class_spec.rb

@@ -1,240 +0,0 @@
-#
-# Author:: Lamont Granquist (<lamont@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 class" do
-  let(:platform) { "debian" }
-
-  let(:node) do
-    node = Chef::Node.new
-    node.automatic["platform"] = platform
-    node
-  end
-
-  let(:run_context) do
-    Chef::RunContext.new(node, nil, nil)
-  end
-
-  let(:resource_priority_map) do
-    double("Chef::Platform::ResourcePriorityMap")
-  end
-
-  let(:provider_priority_map) do
-    double("Chef::Platform::ProviderPriorityMap")
-  end
-
-  before do
-    Chef.set_run_context(run_context)
-    Chef.set_node(node)
-    Chef.set_resource_priority_map(resource_priority_map)
-    Chef.set_provider_priority_map(provider_priority_map)
-  end
-
-  context "priority maps" do
-    context "#get_provider_priority_array" do
-      it "should use the current node to get the right priority_map" do
-        expect(provider_priority_map).to receive(:get_priority_array).with(node, :http_request).and_return("stuff")
-        expect(Chef.get_provider_priority_array(:http_request)).to eql("stuff")
-      end
-    end
-    context "#get_resource_priority_array" do
-      it "should use the current node to get the right priority_map" do
-        expect(resource_priority_map).to receive(:get_priority_array).with(node, :http_request).and_return("stuff")
-        expect(Chef.get_resource_priority_array(:http_request)).to eql("stuff")
-      end
-    end
-    context "#set_provider_priority_array" do
-      it "should delegate to the provider_priority_map" do
-        expect(provider_priority_map).to receive(:set_priority_array).with(:http_request, %w{a b}, platform: "debian").and_return("stuff")
-        expect(Chef.set_provider_priority_array(:http_request, %w{a b}, platform: "debian")).to eql("stuff")
-      end
-    end
-    context "#set_priority_map_for_resource" do
-      it "should delegate to the resource_priority_map" do
-        expect(resource_priority_map).to receive(:set_priority_array).with(:http_request, %w{a b}, platform: "debian").and_return("stuff")
-        expect(Chef.set_resource_priority_array(:http_request, %w{a b}, platform: "debian")).to eql("stuff")
-      end
-    end
-  end
-
-  context "#run_context" do
-    it "should return the injected RunContext" do
-      expect(Chef.run_context).to eql(run_context)
-    end
-  end
-
-  context "#node" do
-    it "should return the injected Node" do
-      expect(Chef.node).to eql(node)
-    end
-  end
-
-  context "#event_handler" do
-    it "adds a new handler" do
-      x = 1
-      Chef.event_handler do
-        on :converge_start do
-          x = 2
-        end
-      end
-      expect(Chef::Config[:event_handlers]).to_not be_empty
-      Chef::Config[:event_handlers].first.send(:converge_start)
-      expect(x).to eq(2)
-    end
-
-    it "raise error if unknown event type is passed" do
-      expect do
-        Chef.event_handler do
-          on :yolo do
-          end
-        end
-      end.to raise_error(Chef::Exceptions::InvalidEventType)
-    end
-  end
-
-  describe "Deprecation system" do
-    context "with treat_deprecation_warnings_as_errors false" do
-      before { Chef::Config[:treat_deprecation_warnings_as_errors] = false }
-
-      it "displays a simple deprecation warning" do
-        expect(Chef::Log).to receive(:warn).with(%r{spec/unit/chef_class_spec\.rb.*?I'm a little teapot.*?Please see}m)
-        Chef.deprecated(:generic, "I'm a little teapot.")
-      end
-
-      it "allows silencing all warnings" do
-        Chef::Config[:silence_deprecation_warnings] = true
-        expect(Chef::Log).to_not receive(:warn)
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:internal_api, "Short and stout.")
-        Chef.deprecated(:generic, "This is my handle.")
-      end
-
-      it "allows silencing specific types" do
-        Chef::Config[:silence_deprecation_warnings] = [:internal_api]
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:internal_api, "Short and stout.")
-        Chef.deprecated(:generic, "This is my handle.")
-      end
-
-      it "allows silencing specific IDs" do
-        Chef::Config[:silence_deprecation_warnings] = [0]
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:internal_api, "Short and stout.")
-        Chef.deprecated(:generic, "This is my handle.")
-      end
-
-      it "allows silencing specific IDs without matching the line number" do
-        Chef::Config[:silence_deprecation_warnings] = [__LINE__ + 4]
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/Short and stout/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:internal_api, "Short and stout.")
-        Chef.deprecated(:generic, "This is my handle.")
-      end
-
-      it "allows silencing specific IDs using the CHEF- syntax" do
-        Chef::Config[:silence_deprecation_warnings] = ["CHEF-0"]
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:internal_api, "Short and stout.")
-        Chef.deprecated(:generic, "This is my handle.")
-      end
-
-      it "allows silencing specific IDs using the chef- syntax" do
-        Chef::Config[:silence_deprecation_warnings] = ["chef-0"]
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:internal_api, "Short and stout.")
-        Chef.deprecated(:generic, "This is my handle.")
-      end
-
-      it "allows silencing specific lines" do
-        Chef::Config[:silence_deprecation_warnings] = ["chef_class_spec.rb:#{__LINE__ + 4}"]
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:generic, "Short and stout.")
-        Chef.deprecated(:internal_api, "This is my handle.")
-      end
-
-      it "allows silencing all via inline comments" do
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:generic, "Short and stout.") # chef:silence_deprecation
-        Chef.deprecated(:internal_api, "This is my handle.")
-      end
-
-      it "allows silencing specific types via inline comments" do
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:generic, "Short and stout.") # chef:silence_deprecation:generic
-        Chef.deprecated(:internal_api, "This is my handle.")
-      end
-
-      it "does not silence via inline comments when the types don't match" do
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/Short and stout/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:internal_api, "Short and stout.") # chef:silence_deprecation:generic
-        Chef.deprecated(:internal_api, "This is my handle.")
-      end
-
-      it "allows silencing all via inline comments with other stuff in the comment" do
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my handle/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:generic, "Short and stout.") # rubocop:something chef:silence_deprecation other stuff
-        Chef.deprecated(:internal_api, "This is my handle.")
-      end
-
-      it "handles multiple silence configurations at the same time" do
-        Chef::Config[:silence_deprecation_warnings] = ["exit_code", "chef_class_spec.rb:#{__LINE__ + 6}"]
-        expect(Chef::Log).to receive(:warn).with(/I'm a little teapot/).once
-        expect(Chef::Log).to receive(:warn).with(/This is my spout/).once
-        expect(Chef::Log).to receive(:warn).with(/Hear me shout/).once
-        Chef.deprecated(:generic, "I'm a little teapot.")
-        Chef.deprecated(:generic, "Short and stout.") # chef:silence_deprecation
-        Chef.deprecated(:internal_api, "This is my handle.")
-        Chef.deprecated(:internal_api, "This is my spout.")
-        Chef.deprecated(:exit_code, "When I get all steamed up.")
-        Chef.deprecated(:generic, "Hear me shout.")
-      end
-    end
-
-    context "with treat_deprecation_warnings_as_errors true" do
-      # This is already turned on globally for Chef's unit tests, but just for clarity do it here too.
-      before { Chef::Config[:treat_deprecation_warnings_as_errors] = true }
-
-      it "displays a simple deprecation error" do
-        expect(Chef::Log).to receive(:error).with(%r{spec/unit/chef_class_spec\.rb.*?I'm a little teapot.*?Please see}m)
-        expect { Chef.deprecated(:generic, "I'm a little teapot.") }.to raise_error(/I'm a little teapot./)
-      end
-    end
-  end
-end

data/spec/unit/chef_fs/config_spec.rb

@@ -1,235 +0,0 @@
-#
-# Author:: Jess Mink (<jmink@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/exceptions"
-require "lib/chef/chef_fs/config"
-
-describe Chef::ChefFS::Config do
-  describe "initialize" do
-    it "warns when hosted setups use 'everything'" do
-      base_config = {}
-      base_config[:repo_mode] = "everything"
-      base_config[:chef_server_url] = "http://foo.com/organizations/fake_org/"
-
-      ui = double("ui")
-      expect(ui).to receive(:warn)
-
-      Chef::ChefFS::Config.new(base_config, Dir.pwd, {}, ui)
-    end
-
-    it "doesn't warn when hosted setups use 'hosted_everything'" do
-      base_config = {}
-      base_config[:repo_mode] = "hosted_everything"
-      base_config[:chef_server_url] = "http://foo.com/organizations/fake_org/"
-
-      ui = double("ui")
-      expect(ui).to receive(:warn).exactly(0).times
-
-      Chef::ChefFS::Config.new(base_config, Dir.pwd, {}, ui)
-    end
-
-    it "doesn't warn when non-hosted setups use 'everything'" do
-      base_config = {}
-      base_config[:repo_mode] = "everything"
-      base_config[:chef_server_url] = "http://foo.com/"
-
-      ui = double("ui")
-      expect(ui).to receive(:warn).exactly(0).times
-
-      Chef::ChefFS::Config.new(base_config, Dir.pwd, {}, ui)
-    end
-  end
-
-  describe "local FS configuration" do
-
-    let(:chef_config) do
-      Mash.new({
-        client_path: "/base_path/clients",
-        cookbook_path: "/base_path/cookbooks",
-        data_bag_path: "/base_path/data_bags",
-        environment_path: "/base_path/environments",
-        node_path: "/base_path/nodes",
-        role_path: "/base_path/roles",
-        user_path: "/base_path/users",
-        policy_path: "/base_path/policies",
-      })
-    end
-
-    let(:chef_fs_config) { Chef::ChefFS::Config.new(chef_config, Dir.pwd) }
-
-    subject(:local_fs) { chef_fs_config.local_fs }
-
-    def platform_path(*args)
-      File.expand_path(*args)
-    end
-
-    it "sets the correct nodes path on the local FS object" do
-      expect(local_fs.child_paths["nodes"]).to eq([platform_path("/base_path/nodes")])
-    end
-
-    it "sets the correct cookbook path on the local FS object" do
-      expect(local_fs.child_paths["cookbooks"]).to eq([platform_path("/base_path/cookbooks")])
-    end
-
-    it "sets the correct data bag path on the local FS object" do
-      expect(local_fs.child_paths["data_bags"]).to eq([platform_path("/base_path/data_bags")])
-    end
-
-    it "sets the correct environment path on the local FS object" do
-      expect(local_fs.child_paths["environments"]).to eq([platform_path("/base_path/environments")])
-    end
-
-    it "sets the correct role path on the local FS object" do
-      expect(local_fs.child_paths["roles"]).to eq([platform_path("/base_path/roles")])
-    end
-
-    it "sets the correct user path on the local FS object" do
-      expect(local_fs.child_paths["users"]).to eq([platform_path("/base_path/users")])
-    end
-  end
-
-  describe "formats paths", :unix_only do
-
-    let(:single_repo_path) do
-      Mash.new({
-        chef_repo_path: "/base_path",
-      })
-    end
-
-    let(:double_repo_path) do
-      Mash.new({
-        chef_repo_path: %w{ /base_path /second_base_path },
-      })
-    end
-
-    describe "#server_path" do
-      it "returns nil if no paths match" do
-        cfg = Chef::ChefFS::Config.new(single_repo_path, "/my_repo/cookbooks")
-        expect(cfg.server_path("foo")).to be_nil
-      end
-
-      context "with only repo paths" do
-        it "returns / if in the repo path" do
-          cwd = "/base_path/cookbooks"
-          cfg = Chef::ChefFS::Config.new(single_repo_path, cwd)
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("/base_path/cookbooks", cwd).and_return("/base_path/cookbooks")
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("/base_path", cwd).and_return("/base_path/cookbooks")
-          expect(cfg.server_path("/base_path/cookbooks")).to eq("/")
-        end
-
-        it "checks all the repo paths" do
-          cwd = "/second_base_path/cookbooks"
-          cfg = Chef::ChefFS::Config.new(double_repo_path, cwd)
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("/second_base_path/cookbooks", cwd).and_return("/second_base_path/cookbooks")
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("/base_path", cwd).and_return("/base_path/cookbooks")
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("/second_base_path", cwd).and_return("/second_base_path/cookbooks")
-          expect(cfg.server_path("/second_base_path/cookbooks")).to eq("/")
-        end
-      end
-
-      context "with specific object locations" do
-        let(:single_cookbook_path) do
-          Mash.new({
-            cookbook_path: "/base_path/cookbooks",
-            role_path: "/base_path/roles",
-          })
-        end
-
-        let(:cwd) { "/base_path/cookbooks" }
-        let(:cfg) { Chef::ChefFS::Config.new(single_cookbook_path, cwd) }
-
-        before do
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("/base_path/cookbooks", cwd).and_return("/base_path/cookbooks")
-          allow(Chef::ChefFS::PathUtils).to receive(:realest_path).with("/base_path/roles", cwd).and_return("/base_path/roles")
-        end
-
-        it "resolves a relative path" do
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("blah", cwd).and_return("/base_path/cookbooks/blah")
-          expect(cfg.server_path("blah")).to eql("/cookbooks/blah")
-        end
-
-        it "resolves a relative path in a parent directory" do
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("../roles/blah", cwd).and_return("/base_path/roles/blah")
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("/base_path/roles", cwd).and_return("/base_path/roles")
-          expect(cfg.server_path("../roles/blah")).to eql("/roles/blah")
-        end
-
-        it "ignores a relative path that's outside the repository" do
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("../../readme.txt", cwd).and_return("/readme.txt")
-          expect(cfg.server_path("../../readme.txt")).to be_nil
-        end
-
-        it "deals with splat paths" do
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("*/*ab*", cwd).and_return("/base_path/cookbooks/*/*ab*")
-          expect(cfg.server_path("*/*ab*")).to eql("/cookbooks/*/*ab*")
-        end
-
-        it "resolves an absolute path" do
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("/base_path/cookbooks/blah", cwd).and_return("/base_path/cookbooks/blah")
-          expect(cfg.server_path("/base_path/cookbooks/blah")).to eql("/cookbooks/blah")
-        end
-
-        it "deals with an absolute path with splats" do
-          expect(Chef::ChefFS::PathUtils).to receive(:realest_path).with("/*/cookbooks/blah", cwd).and_return("/*/cookbooks/blah")
-          expect(cfg.server_path("/*/cookbooks/blah")).to be_nil
-        end
-      end
-    end
-
-    describe "#format_path" do
-      Entry = Struct.new(:path)
-
-      let(:config) do
-        Mash.new({
-          chef_repo_path: "/base_path",
-          cookbook_path: "/base_path/cookbooks",
-          role_path: "/base_path/roles",
-        })
-      end
-
-      let(:path) { "/roles/foo.json" }
-      let(:entry) { Entry.new(path) }
-
-      it "returns the entry's path if the cwd isn't in the config" do
-        cfg = Chef::ChefFS::Config.new(config, "/my_repo/cookbooks")
-        expect(cfg).to receive(:base_path).and_return(nil)
-        expect(cfg.format_path(entry)).to eq(path)
-      end
-
-      it "returns . if the cwd is the same as the entry's path" do
-        cfg = Chef::ChefFS::Config.new(config, "/base_path/roles/foo.json")
-        expect(cfg).to receive(:base_path).and_return("/roles/foo.json").at_least(:once)
-        expect(cfg.format_path(entry)).to eq(".")
-      end
-
-      it "returns a relative path if the cwd is in the repo" do
-        cfg = Chef::ChefFS::Config.new(config, "/base_path/roles")
-        expect(cfg).to receive(:base_path).and_return("/roles").at_least(:once)
-        expect(cfg.format_path(entry)).to eq("foo.json")
-      end
-
-      it "returns a relative path if the cwd is at the root of repo" do
-        cfg = Chef::ChefFS::Config.new(config, "/base_path")
-        expect(cfg).to receive(:base_path).and_return("/").at_least(:once)
-        expect(cfg.format_path(entry)).to eq("roles/foo.json")
-      end
-
-    end
-  end
-end

data/spec/unit/chef_fs/data_handler/data_bag_item_data_handler.rb

@@ -1,82 +0,0 @@
-#
-# Author:: Sandra Tiffin (<sandi.tiffin@gmail.com>)
-# 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 "lib/chef/chef_fs/data_handler/data_bag_item_data_handler"
-
-class TestDataBag < Mash
-  attr_accessor :name
-
-  def initialize(bag_name)
-    @name = bag_name
-  end
-end
-
-class TestDataBagItem < Mash
-  attr_accessor :name, :parent
-
-  def path_for_printing
-    "/some/path"
-  end
-
-  def initialize(bag_name, item_name)
-    @name = "#{item_name}.json"
-    @parent = TestDataBag.new(bag_name)
-  end
-end
-
-describe Chef::ChefFS::DataHandler::DataBagItemDataHandler do
-  let(:handler) { described_class.new }
-
-  describe "#verify_integrity" do
-    context "json id does not match data bag item name" do
-      let(:entry) { TestDataBagItem.new("luggage", "bag") }
-      let(:object) do
-        { "raw_data" => { "id" => "duffel" } }
-      end
-      it "rejects the data bag item name" do
-        expect { |b| handler.verify_integrity(object, entry, &b) }.to yield_with_args
-      end
-    end
-
-    context "using a reserved word for the data bag name" do
-      %w{node role environment client}.each do |reserved_word|
-        let(:entry) { TestDataBagItem.new(reserved_word, "bag") }
-        let(:object) do
-          { "raw_data" => { "id" => "bag" } }
-        end
-        it "rejects the data bag name '#{reserved_word}'" do
-          expect { |b| handler.verify_integrity(object, entry, &b) }.to yield_with_args
-        end
-      end
-    end
-
-    context "using a reserved word as part of the data bag name" do
-      %w{xnode rolex xenvironmentx xclientx}.each do |bag_name|
-        let(:entry) { TestDataBagItem.new(bag_name.to_s, "bag") }
-        let(:object) do
-          { "raw_data" => { "id" => "bag" } }
-        end
-        it "allows the data bag name '#{bag_name}'" do
-          expect(handler.verify_integrity(object, entry)).to be_nil
-        end
-      end
-    end
-
-  end
-end

data/spec/unit/chef_fs/data_handler/data_handler_base_spec.rb

@@ -1,65 +0,0 @@
-#
-# Author:: Jeremy Miller (<jm@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 "lib/chef/chef_fs/data_handler/data_handler_base"
-
-describe Chef::ChefFS::DataHandler::DataHandlerBase do
-  describe "#normalize_hash" do
-    let(:some_item) do
-      { "name" => "grizzly",
-        "gender" => "female",
-        "age" => 3,
-        "food" => "honey",
-      }
-    end
-
-    let(:item_defaults) do
-      { "family" => "ursidae",
-        "hibernate" => true,
-        "food" => "berries",
-        "avg_lifespan_years" => 22,
-      }
-    end
-
-    let(:normalized) do
-      { "name" => "grizzly",
-        "gender" => "female",
-        "family" => "ursidae",
-        "hibernate" => true,
-        "avg_lifespan_years" => 22,
-        "age" => 3,
-        "food" => "honey",
-      }
-    end
-
-    let(:handler) { described_class.new }
-
-    it "normalizes the Hash, filling in default values" do
-      expect(handler.normalize_hash(some_item, item_defaults)).to eq(normalized)
-    end
-
-    it "prefers already existing values over default values" do
-      expect(handler.normalize_hash(some_item, item_defaults)["food"]).to eq("honey")
-    end
-
-    it "handles being passed a nil value instead of Hash" do
-      expect(handler.normalize_hash(nil, item_defaults)).to eq(item_defaults)
-    end
-  end
-end

data/spec/unit/chef_fs/data_handler/group_handler_spec.rb

@@ -1,63 +0,0 @@
-#
-# Author:: Ryan Cragun (<ryan@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 "lib/chef/chef_fs/data_handler/group_data_handler"
-
-class TestEntry < Mash
-  attr_accessor :name, :org
-
-  def initialize(name, org)
-    @name = name
-    @org = org
-  end
-end
-
-describe Chef::ChefFS::DataHandler::GroupDataHandler do
-  describe "#normalize_for_post" do
-    let(:entry) do
-      TestEntry.new("workers.json", "hive")
-    end
-
-    let(:group) do
-      { "name" => "worker_bees",
-        "clients" => %w{honey sting},
-        "users" => %w{fizz buzz},
-        "actors" => %w{honey},
-      }
-    end
-
-    let(:normalized) do
-      { "actors" =>
-          { "users" => %w{fizz buzz},
-            "clients" => %w{honey sting},
-            "groups" => [],
-          },
-        "groupname" => "workers",
-        "name" => "worker_bees",
-        "orgname" => "hive",
-      }
-    end
-
-    let(:handler) { described_class.new }
-
-    it "normalizes the users, clients and groups into actors" do
-      expect(handler.normalize_for_post(group, entry)).to eq(normalized)
-    end
-  end
-end