chef 18.7.10 → 18.8.46

data/spec/unit/cookbook/chefignore_spec.rb

@@ -1,69 +0,0 @@
-#--
-# Author:: Daniel DeLeo (<dan@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::Cookbook::Chefignore do
-  let(:chefignore) { described_class.new(File.join(CHEF_SPEC_DATA, "cookbooks")) }
-
-  it "loads the globs in the chefignore file" do
-    expect(chefignore.ignores).to match_array(%w{recipes/ignoreme.rb ignored})
-  end
-
-  it "removes items from an array that match the ignores" do
-    file_list = %w{ recipes/ignoreme.rb recipes/dontignoreme.rb }
-    expect(chefignore.remove_ignores_from(file_list)).to eq(%w{recipes/dontignoreme.rb})
-  end
-
-  it "determines if a file is ignored" do
-    expect(chefignore.ignored?("ignored")).to be_truthy
-    expect(chefignore.ignored?("recipes/ignoreme.rb")).to be_truthy
-    expect(chefignore.ignored?("recipes/dontignoreme.rb")).to be_falsey
-  end
-
-  context "when using the single cookbook pattern" do
-    let(:chefignore) { described_class.new(File.join(CHEF_SPEC_DATA, "cookbooks/starter")) }
-
-    it "loads the globs in the chefignore file" do
-      expect(chefignore.ignores).to match_array(%w{recipes/default.rb ignored})
-    end
-  end
-
-  context "when cookbook has it's own chefignore" do
-    let(:chefignore) { described_class.new(File.join(CHEF_SPEC_DATA, "cookbooks/starter")) }
-
-    it "loads the globs in the chefignore file" do
-      expect(chefignore.ignores).to match_array(%w{recipes/default.rb ignored})
-    end
-  end
-
-  context "when cookbook don't have own chefignore" do
-    let(:chefignore) { described_class.new(File.join(CHEF_SPEC_DATA, "cookbooks/apache2")) }
-
-    it "loads the globs in the chefignore file of cookbooks dir" do
-      expect(chefignore.ignores).to match_array(%w{recipes/ignoreme.rb ignored})
-    end
-  end
-
-  context "when using the single cookbook pattern" do
-    let(:chefignore) { described_class.new(File.join(CHEF_SPEC_DATA, "standalone_cookbook")) }
-
-    it "loads the globs in the chefignore file" do
-      expect(chefignore.ignores).to match_array(%w{recipes/ignoreme.rb ignored vendor/bundle/*})
-    end
-  end
-end

data/spec/unit/cookbook/cookbook_version_loader_spec.rb

@@ -1,213 +0,0 @@
-#
-# Author:: Daniel DeLeo (<dan@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::Cookbook::CookbookVersionLoader do
-  before do
-    allow(ChefUtils).to receive(:windows?) { false }
-  end
-
-  describe "loading a cookbook" do
-
-    let(:chefignore) { nil }
-
-    let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks/openldap") }
-
-    let(:cookbook_loader) { Chef::Cookbook::CookbookVersionLoader.new(cookbook_path, chefignore) }
-
-    let(:loaded_cookbook) do
-      cookbook_loader.load!
-      cookbook_loader.cookbook_version
-    end
-
-    def full_path(cookbook_relative_path)
-      File.join(cookbook_path, cookbook_relative_path)
-    end
-
-    def full_paths_for_part(part)
-      loaded_cookbook.files_for(part).inject([]) { |memo, f| memo << f[:full_path]; memo }
-    end
-
-    it "loads attribute files of the cookbook" do
-      expect(full_paths_for_part("attributes")).to include(full_path("/attributes/default.rb"))
-      expect(full_paths_for_part("attributes")).to include(full_path("/attributes/smokey.rb"))
-    end
-
-    it "loads definition files" do
-      expect(full_paths_for_part("definitions")).to include(full_path("/definitions/client.rb"))
-      expect(full_paths_for_part("definitions")).to include(full_path("/definitions/server.rb"))
-    end
-
-    it "loads recipes" do
-      expect(full_paths_for_part("recipes")).to include(full_path("/recipes/default.rb"))
-      expect(full_paths_for_part("recipes")).to include(full_path("/recipes/gigantor.rb"))
-      expect(full_paths_for_part("recipes")).to include(full_path("/recipes/one.rb"))
-      expect(full_paths_for_part("recipes")).to include(full_path("/recipes/return.rb"))
-    end
-
-    it "loads libraries" do
-      expect(full_paths_for_part("libraries")).to include(full_path("/libraries/openldap.rb"))
-      expect(full_paths_for_part("libraries")).to include(full_path("/libraries/openldap/version.rb"))
-    end
-
-    it "loads static files in the files/ dir" do
-      expect(full_paths_for_part("files")).to include(full_path("/files/default/remotedir/remotesubdir/remote_subdir_file1.txt"))
-      expect(full_paths_for_part("files")).to include(full_path("/files/default/remotedir/remotesubdir/remote_subdir_file2.txt"))
-    end
-
-    it "loads files that start with a ." do
-      expect(full_paths_for_part("files")).to include(full_path("/files/default/.dotfile"))
-      expect(full_paths_for_part("files")).to include(full_path("/files/default/.ssh/id_rsa"))
-      expect(full_paths_for_part("files")).to include(full_path("/files/default/remotedir/.a_dotdir/.a_dotfile_in_a_dotdir"))
-    end
-
-    it "loads root files that start with a ." do
-      expect(loaded_cookbook.all_files).to include(full_path(".root_dotfile"))
-    end
-
-    it "loads all unignored files, even if they don't match a segment type" do
-      expect(loaded_cookbook.all_files).to include(full_path("/spec/spec_helper.rb"))
-
-      # Directories need to be filtered out, though:
-      expect(loaded_cookbook.all_files).to_not include(full_path("/spec"))
-    end
-
-    it "should load the metadata for the cookbook" do
-      expect(loaded_cookbook.metadata.name.to_s).to eq("openldap")
-      expect(loaded_cookbook.metadata).to be_a_kind_of(Chef::Cookbook::Metadata)
-    end
-
-    context "when a cookbook has ignored files" do
-
-      let(:chefignore) { Chef::Cookbook::Chefignore.new(File.join(CHEF_SPEC_DATA, "cookbooks")) }
-
-      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "kitchen/openldap") }
-
-      it "skips ignored files" do
-        expect(full_paths_for_part("recipes")).to include(full_path("recipes/gigantor.rb"))
-        expect(full_paths_for_part("recipes")).to include(full_path("recipes/woot.rb"))
-        expect(full_paths_for_part("recipes")).to_not include(full_path("recipes/ignoreme.rb"))
-      end
-
-    end
-
-    context "when a cookbook's metadata.rb does not parse but the compiled metadata.json is present" do
-      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "prefer_metadata_json") }
-
-      it "reads the cookbook" do
-        expect(loaded_cookbook.metadata.name.to_s).to eq("prefer_metadata_json")
-        expect(loaded_cookbook.metadata.version.to_s).to eq("1.2.3")
-      end
-    end
-
-    context "when the given path is not actually a cookbook" do
-
-      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks/NOTHING_HERE_FOLKS") }
-
-      it "raises an error when loading with #load!" do
-        expect { cookbook_loader.load! }.to raise_error(Chef::Exceptions::CookbookNotFoundInRepo)
-      end
-
-      it "gives deprecation warning called with #load" do
-        Chef::Config[:treat_deprecation_warnings_as_errors] = false
-        cookbook_loader.load
-      end
-
-    end
-
-    context "when a cookbook has a metadata name different than directory basename" do
-
-      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks/name-mismatch-versionnumber") }
-
-      it "prefers the metadata name to the directory basename" do
-        expect(loaded_cookbook.name).to eq(:"name-mismatch")
-      end
-
-    end
-
-    context "when a cookbook has a metadata file with a ruby error [CHEF-2923]" do
-
-      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "invalid-metadata-chef-repo/invalid-metadata") }
-
-      it "raises an error when loading with #load!" do
-        expect { cookbook_loader.load! }.to raise_error("THIS METADATA HAS A BUG")
-      end
-
-      it "gives deprecation warning to us load!  when called with #load and raises error" do
-        Chef::Config[:treat_deprecation_warnings_as_errors] = false
-        expect { cookbook_loader.load }.to raise_error("THIS METADATA HAS A BUG")
-      end
-
-      it "doesn't raise an error when determining the cookbook name" do
-        expect { cookbook_loader.cookbook_name }.to_not raise_error
-      end
-
-      it "doesn't raise an error when metadata is first generated" do
-        expect { cookbook_loader.metadata }.to_not raise_error
-      end
-
-      it "sets an error flag containing error information" do
-        cookbook_loader.metadata
-        expect(cookbook_loader.metadata_error).to be_a(StandardError)
-        expect(cookbook_loader.metadata_error.message).to eq("THIS METADATA HAS A BUG")
-      end
-
-    end
-
-    context "when a cookbook has a metadata file with invalid metadata" do
-
-      let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "incomplete-metadata-chef-repo/incomplete-metadata") }
-
-      let(:error_message) do
-        "Cookbook loaded at path [#{cookbook_path}] has invalid metadata: The `name' attribute is required in cookbook metadata"
-      end
-
-      it "raises an error when loading with #load!" do
-        expect { cookbook_loader.load! }.to raise_error(Chef::Exceptions::MetadataNotValid, error_message)
-      end
-
-      it "gives deprecation warning to use load! method when called with #load and raises error for invalid metadata" do
-        Chef::Config[:treat_deprecation_warnings_as_errors] = false
-        expect { cookbook_loader.load }.to raise_error(Chef::Exceptions::MetadataNotValid, error_message)
-      end
-
-      it "uses the inferred cookbook name [CHEF-2923]" do
-        # This behavior is intended to support the CHEF-2923 feature where
-        # invalid metadata doesn't prevent you from uploading other cookbooks.
-        #
-        # The metadata is the definitive source of the cookbook name, but if
-        # the metadata is incomplete/invalid, we can't read the name from it.
-        #
-        # The CookbookLoader stores CookbookVersionLoaders in a Hash with
-        # cookbook names as the keys, and finds the loader in this Hash to call
-        # #load on it when the user runs a command like `knife cookbook upload specific-cookbook`
-        #
-        # Most of the time this will work, but if the user tries to upload a
-        # specific cookbook by name, has customized that cookbook's name (so it
-        # doesn't match the inferred name), and that metadata file has a syntax
-        # error, we might report a "cookbook not found" error instead of the
-        # metadata syntax error that is the actual cause.
-        expect(cookbook_loader.cookbook_name).to eq(:"incomplete-metadata")
-      end
-
-    end
-
-  end
-
-end

data/spec/unit/cookbook/file_vendor_spec.rb

@@ -1,123 +0,0 @@
-#--
-# Author:: Daniel DeLeo (<dan@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/cookbook_version"
-
-describe Chef::Cookbook::FileVendor do
-
-  let(:file_vendor_class) { Class.new(described_class) }
-
-  context "when configured to fetch files over http" do
-
-    let(:http) { double("Chef::ServerAPI") }
-
-    # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
-    let(:manifest) do
-      cbv = Chef::CookbookVersion.new("bob", Array(Dir.tmpdir))
-      cbv.cookbook_manifest
-    end
-
-    before do
-      file_vendor_class.fetch_from_remote(http)
-    end
-
-    it "sets the vendor class to RemoteFileVendor" do
-      expect(file_vendor_class.vendor_class).to eq(Chef::Cookbook::RemoteFileVendor)
-    end
-
-    it "sets the initialization options to the given http object" do
-      expect(file_vendor_class.initialization_options).to eq(http)
-    end
-
-    context "with a manifest from a cookbook version" do
-
-      # # A manifest is a Hash of the format defined by Chef::CookbookVersion#manifest
-      # let(:manifest) do
-      #   cbv = Chef::CookbookVersion.new("bob", Array(Dir.tmpdir))
-      #   cbv.cookbook_manifest
-      # end
-
-      it "creates a RemoteFileVendor for a given manifest" do
-        file_vendor = file_vendor_class.create_from_manifest(manifest)
-        expect(file_vendor).to be_a_kind_of(Chef::Cookbook::RemoteFileVendor)
-        expect(file_vendor.rest).to eq(http)
-        expect(file_vendor.cookbook_name).to eq("bob")
-      end
-
-    end
-
-    context "with a manifest from a cookbook artifact" do
-
-      it "creates a RemoteFileVendor for a given manifest" do
-        file_vendor = file_vendor_class.create_from_manifest(manifest)
-        expect(file_vendor).to be_a_kind_of(Chef::Cookbook::RemoteFileVendor)
-        expect(file_vendor.rest).to eq(http)
-        expect(file_vendor.cookbook_name).to eq("bob")
-      end
-
-    end
-  end
-
-  context "when configured to load files from disk" do
-
-    let(:cookbook_path) { %w{/var/chef/cookbooks /var/chef/other_cookbooks} }
-
-    let(:manifest) do
-      cbv = Chef::CookbookVersion.new("bob", Array(Dir.tmpdir))
-      cbv.cookbook_manifest
-    end
-
-    before do
-      file_vendor_class.fetch_from_disk(cookbook_path)
-    end
-
-    it "sets the vendor class to FileSystemFileVendor" do
-      expect(file_vendor_class.vendor_class).to eq(Chef::Cookbook::FileSystemFileVendor)
-    end
-
-    it "sets the initialization options to the given cookbook paths" do
-      expect(file_vendor_class.initialization_options).to eq(cookbook_path)
-    end
-
-    it "creates a FileSystemFileVendor for a given manifest" do
-      file_vendor = file_vendor_class.create_from_manifest(manifest)
-      expect(file_vendor).to be_a_kind_of(Chef::Cookbook::FileSystemFileVendor)
-      expect(file_vendor.cookbook_name).to eq("bob")
-      expect(file_vendor.repo_paths).to eq(cookbook_path)
-    end
-
-  end
-
-  context "when vendoring a cookbook with a name mismatch" do
-    let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks") }
-
-    let(:manifest) do
-      cbv = Chef::CookbookVersion.new("name-mismatch", Array(Dir.tmpdir))
-      cbv.cookbook_manifest
-    end
-
-    before do
-      file_vendor_class.fetch_from_disk(cookbook_path)
-    end
-
-    it "retrieves the file from the correct location based on path to the cookbook that contains the correct name metadata" do
-      file_vendor = file_vendor_class.create_from_manifest(manifest)
-      file_vendor.get_filename("metadata.rb")
-    end
-  end
-end

data/spec/unit/cookbook/gem_installer_spec.rb

@@ -1,114 +0,0 @@
-require "spec_helper"
-require "bundler"
-
-describe Chef::Cookbook::GemInstaller do
-  let(:cookbook_collection) do
-    {
-      test: double(
-        :cookbook,
-        metadata: double(
-          :metadata,
-          gems: [["httpclient"], ["nokogiri"]]
-        )
-      ),
-      test2: double(
-        :cookbook,
-        metadata: double(
-          :metadata,
-          gems: [["httpclient", ">= 2.0"]]
-        )
-      ),
-      test3: double(
-        :cookbook,
-        metadata: double(
-          :metadata,
-          gems: [["httpclient", ">= 1.0", { "git" => "https://github.com/nahi/httpclient" }]]
-        )
-      ),
-      test4: double(
-        :cookbook,
-        metadata: double(
-          :metadata,
-          gems: [["httpclient", { "path" => "./gems/httpclient" }]]
-        )
-      ),
-    }
-  end
-
-  let(:gem_installer) do
-    described_class.new(cookbook_collection, Chef::EventDispatch::Dispatcher.new)
-  end
-
-  let(:gemfile) do
-    StringIO.new
-  end
-
-  let(:shell_out) do
-    double(:shell_out, stdout: "")
-  end
-
-  let(:bundler_dsl) do
-    b = Bundler::Dsl.new
-    b.instance_eval(gemfile.string)
-    b
-  end
-
-  before(:each) do
-    # Prepare mocks: using a StringIO instead of a File
-    expect(Dir).to receive(:mktmpdir).and_yield("")
-    expect(File).to receive(:open).and_yield(gemfile)
-    expect(gemfile).to receive(:path).and_return("")
-    expect(IO).to receive(:read).and_return("")
-
-  end
-
-  it "generates a valid Gemfile" do
-    expect(gem_installer).to receive(:shell_out!).and_return(shell_out)
-    expect { gem_installer.install }.to_not raise_error
-
-    expect { bundler_dsl }.to_not raise_error
-  end
-
-  it "generate a Gemfile with all constraints" do
-    expect(gem_installer).to receive(:shell_out!).and_return(shell_out)
-    expect { gem_installer.install }.to_not raise_error
-
-    expect(bundler_dsl.dependencies.find { |d| d.name == "httpclient" }.requirements_list.length).to eql(2)
-  end
-
-  it "generates a valid Gemfile when Chef::Config[:rubygems_url] is set to a String" do
-    expect(gem_installer).to receive(:shell_out!).and_return(shell_out)
-    Chef::Config[:rubygems_url] = "https://rubygems.org"
-    expect { gem_installer.install }.to_not raise_error
-
-    expect(bundler_dsl.dependencies.find { |d| d.name == "httpclient" }.requirements_list.length).to eql(2)
-  end
-
-  it "generates a valid Gemfile when Chef::Config[:rubygems_url] is set to an Array" do
-    expect(gem_installer).to receive(:shell_out!).and_return(shell_out)
-    Chef::Config[:rubygems_url] = [ "https://rubygems.org" ]
-
-    expect { gem_installer.install }.to_not raise_error
-
-    expect(bundler_dsl.dependencies.find { |d| d.name == "httpclient" }.requirements_list.length).to eql(2)
-  end
-
-  it "skip metadata installation when Chef::Config[:skip_gem_metadata_installation] is set to true" do
-    Chef::Config[:skip_gem_metadata_installation] = true
-    expect(gem_installer).to_not receive(:shell_out!)
-    expect(gem_installer.install).to be_nil
-  end
-
-  it "install metadata when Chef::Config[:skip_gem_metadata_installation] is not true" do
-    expect(gem_installer).to receive(:shell_out!).and_return(shell_out)
-    expect(Chef::Log).to receive(:info).and_return("")
-    expect(gem_installer.install).to be_nil
-  end
-
-  it "install from local cache when Chef::Config[:gem_installer_bundler_options] is set to local" do
-    Chef::Config[:gem_installer_bundler_options] = "--local"
-    expect(gem_installer).to receive(:shell_out!).with(["bundle", "install", "--local"], any_args).and_return(shell_out)
-    expect(Chef::Log).to receive(:info).and_return("")
-    expect(gem_installer.install).to be_nil
-  end
-end

data/spec/unit/cookbook/manifest_v0_spec.rb

@@ -1,133 +0,0 @@
-#
-# 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/cookbook_manifest"
-require "chef/digester"
-require "pathname"
-
-describe Chef::Cookbook::ManifestV0 do
-  let(:version) { "1.2.3" }
-
-  let(:identifier) { "9e10455ce2b4a4e29424b7064b1d67a1a25c9d3b" }
-
-  let(:metadata) do
-    Chef::Cookbook::Metadata.new.tap do |m|
-      m.version(version)
-    end
-  end
-
-  let(:cookbook_root) { "/tmp/blah" }
-
-  let(:cookbook_version) do
-    Chef::CookbookVersion.new("tatft", cookbook_root).tap do |c|
-      c.metadata = metadata
-      c.identifier = identifier
-    end
-  end
-
-  let(:cookbook_manifest) { Chef::CookbookManifest.new(cookbook_version) }
-
-  let(:cookbook_root) { File.join(CHEF_SPEC_DATA, "cb_version_cookbooks", "tatft") }
-
-  let(:all_files) { Dir[File.join(cookbook_root, "**", "**")].reject { |f| File.directory? f } }
-
-  let(:expected_hash) do
-    {
-      "attributes" => [{ "name" => "default.rb", "path" => "attributes/default.rb", "checksum" => "a88697db56181498a8828d5531271ad9", "specificity" => "default" }],
-      "chef_type" => "cookbook_version",
-      "cookbook_name" => "tatft",
-      "definitions" => [{ "name" => "runit_service.rb", "path" => "definitions/runit_service.rb", "checksum" => "c40cf9b4c6eb15a8e49e31602f701161", "specificity" => "default" }],
-      "files" => [{ "name" => "giant_blob.tgz", "path" => "files/default/giant_blob.tgz", "checksum" => "5b4b194bb80938bb18da7af5c823cb1b", "specificity" => "default" }],
-      "frozen?" => false,
-      "libraries" => [{ "name" => "ownage.rb", "path" => "libraries/ownage.rb", "checksum" => "4686edd9968909034692e09e058d90d9", "specificity" => "default" }],
-      "name" => "tatft-1.2.3",
-      "providers" => [{ "name" => "lwp.rb", "path" => "providers/lwp.rb", "checksum" => "bc189d68f77bb054d1070aeff7669557", "specificity" => "default" }],
-      "recipes" => [{ "name" => "default.rb", "path" => "recipes/default.rb", "checksum" => "09bc749f00c68717d288de9c8d7c644f", "specificity" => "default" }],
-      "resources" => [{ "name" => "lwr.rb", "path" => "resources/lwr.rb", "checksum" => "609c40d3d3f269e7edf230277a240ef5", "specificity" => "default" }],
-      "root_files" => [{ "name" => "README.rdoc", "path" => "README.rdoc", "checksum" => "cd7be9a1b9b1f33e3bcd9c3f4bc8dde5", "specificity" => "default" }],
-      "templates" => [{ "name" => "configuration.erb", "path" => "templates/default/configuration.erb", "checksum" => "d41d8cd98f00b204e9800998ecf8427e", "specificity" => "default" }],
-      "version" => "1.2.3",
-    }
-  end
-
-  describe "#from_hash" do
-    let(:source_hash) do
-      {
-      "attributes" => [{ "name" => "default.rb", "path" => "attributes/default.rb", "checksum" => "a88697db56181498a8828d5531271ad9", "specificity" => "default" }],
-      "recipes" => [{ "name" => "default.rb", "path" => "recipes/default.rb", "checksum" => "09bc749f00c68717d288de9c8d7c644f", "specificity" => "default" }],
-      "root_files" => [{ "name" => "README.rdoc", "path" => "README.rdoc", "checksum" => "cd7be9a1b9b1f33e3bcd9c3f4bc8dde5", "specificity" => "default" }],
-      "name" => "tatft-1.2.3",
-      "version" => "1.2.3",
-      }
-    end
-
-    it "preserves the version" do
-      result = described_class.from_hash(source_hash)
-      expect(result["version"]).to eq "1.2.3"
-    end
-
-    it "creates an all_files key and populates it" do
-      result = described_class.from_hash(source_hash)
-      expect(result[:all_files].map { |f| f["name"] }).to match_array %w{ recipes/default.rb attributes/default.rb root_files/README.rdoc }
-    end
-
-    it "deletes unwanted segment types" do
-      result = described_class.from_hash(source_hash)
-      expect(result["attributes"]).to be_nil
-    end
-
-    it "preserves frozeness" do
-      source_hash["frozen?"] = true
-      result = described_class.from_hash(source_hash)
-      expect(result["frozen?"]).to be true
-    end
-  end
-
-  describe "#to_hash" do
-    it "accepts a cookbook manifest" do
-      result = described_class.to_hash(cookbook_manifest)
-      expect(result).to be_a(Hash)
-    end
-
-    it "preserves frozeness" do
-      cookbook_version.freeze_version
-      expect(described_class.to_hash(cookbook_manifest)["frozen?"]).to be true
-    end
-  end
-
-  context "ensures that all segments exist" do
-    Chef::Cookbook::ManifestV0::COOKBOOK_SEGMENTS.each do |segment|
-      it "with #{segment}" do
-        result = described_class.to_hash(cookbook_manifest)
-        expect(result[segment]).to be_empty
-      end
-    end
-  end
-
-  context "when given a cookbook with some files" do
-    before do
-      cookbook_version.all_files = all_files
-    end
-
-    Chef::Cookbook::ManifestV0::COOKBOOK_SEGMENTS.each do |segment|
-      it "places the files for #{segment} correctly" do
-        result = described_class.to_hash(cookbook_manifest)
-        expect(result[segment]).to eq(expected_hash[segment])
-      end
-    end
-  end
-end