chef 18.8.11 → 18.8.54

data/spec/unit/cookbook_manifest_spec.rb

@@ -1,228 +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_manifest"
-require "chef/digester"
-require "pathname"
-
-describe Chef::CookbookManifest 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(:policy_mode) { false }
-
-  subject(:cookbook_manifest) { Chef::CookbookManifest.new(cookbook_version, policy_mode: policy_mode) }
-
-  context "when policy mode is not specified" do
-
-    subject(:cookbook_manifest) { Chef::CookbookManifest.new(cookbook_version) }
-
-    it "defaults to policies disabled" do
-      expect(cookbook_manifest.policy_mode?).to be(false)
-    end
-
-  end
-
-  describe "collecting cookbook data from the cookbook version object" do
-
-    it "delegates `name' to cookbook_version" do
-      expect(cookbook_manifest.name).to eq("tatft")
-    end
-
-    it "delegates `root_paths' to cookbook_version" do
-      expect(cookbook_manifest.root_paths).to eq(["/tmp/blah"])
-    end
-
-    it "delegates `metadata' to cookbook_version" do
-      expect(cookbook_manifest.metadata).to eq(metadata)
-    end
-
-    it "delegates `full_name' to cookbook_version" do
-      expect(cookbook_manifest.full_name).to eq("tatft-1.2.3")
-    end
-
-    it "delegates `version' to cookbook_version" do
-      expect(cookbook_manifest.version).to eq(version)
-    end
-
-    it "delegates `frozen_version?' to cookbook_version" do
-      expect(cookbook_manifest.frozen_version?).to be(false)
-    end
-
-  end
-
-  context "when given an empty cookbook" do
-
-    let(:expected_hash) do
-      {
-        "chef_type" => "cookbook_version",
-
-        "name" => "tatft-1.2.3",
-        "version" => "1.2.3",
-        "cookbook_name" => "tatft",
-        "metadata" => metadata,
-
-        "frozen?" => false,
-
-        "all_files" => [],
-      }
-    end
-
-    it "converts the CookbookVersion to a ruby Hash representation" do
-      expect(cookbook_manifest.to_hash).to eq(expected_hash)
-    end
-
-  end
-
-  context "when given a cookbook with files" do
-
-    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(:match_md5) { /[0-9a-f]{32}/ }
-
-    def map_to_file_specs(paths, full: false)
-      paths.map do |path|
-
-        relative_path = Pathname.new(path).relative_path_from(Pathname.new(cookbook_root)).to_s
-
-        parts = relative_path.split("/")
-        name = if %w{templates files}.include?(parts[0]) && parts.length == 3
-                 File.join(parts[0], parts[2])
-               elsif parts.length == 1
-                 "root_files/#{parts[0]}"
-               else
-                 relative_path
-               end
-
-        {
-          "name" => name,
-          "path" => relative_path,
-          "checksum" => Chef::Digester.generate_md5_checksum_for_file(path),
-          "specificity" => "default",
-        }.tap do |fp|
-          if full
-            fp["full_path"] = path
-          end
-        end
-      end
-    end
-
-    let(:expected_hash) do
-      {
-        "chef_type" => "cookbook_version",
-
-        "name" => "tatft-1.2.3",
-        "version" => "1.2.3",
-        "cookbook_name" => "tatft",
-        "metadata" => metadata,
-
-        "frozen?" => false,
-
-        "all_files" => map_to_file_specs(all_files),
-      }
-    end
-
-    before do
-      cookbook_version.all_files = all_files
-    end
-
-    it "converts the CookbookVersion to a ruby Hash representation" do
-      cookbook_manifest_hash = cookbook_manifest.to_hash
-
-      expect(cookbook_manifest_hash.keys).to match_array(expected_hash.keys)
-      cookbook_manifest_hash.each_key do |key|
-        expect(cookbook_manifest_hash[key]).to eq(expected_hash[key])
-      end
-    end
-
-    context ".each_file" do
-      it "yields all the files" do
-        files = map_to_file_specs(all_files, full: true)
-        expect(cookbook_manifest.to_enum(:each_file)).to match_array(files)
-      end
-
-      it "excludes certain file parts" do
-        files = map_to_file_specs(all_files, full: true).reject { |f| seg = f["name"].split("/")[0]; %w{ files templates }.include?(seg) }
-        expect(cookbook_manifest.to_enum(:each_file, excluded_parts: %w{ files templates })).to match_array(files)
-      end
-    end
-  end
-
-  describe "providing upstream URLs for save" do
-
-    context "and policy mode is disabled" do
-
-      it "gives the save URL" do
-        expect(cookbook_manifest.save_url).to eq("cookbooks/tatft/1.2.3")
-      end
-
-      it "gives the force save URL" do
-        expect(cookbook_manifest.force_save_url).to eq("cookbooks/tatft/1.2.3?force=true")
-      end
-
-    end
-
-    context "and policy mode is enabled" do
-
-      let(:policy_mode) { true }
-
-      let(:cookbook_manifest_hash) { cookbook_manifest.to_hash }
-
-      it "sets the identifier in the manifest data" do
-        expect(cookbook_manifest_hash["identifier"]).to eq("9e10455ce2b4a4e29424b7064b1d67a1a25c9d3b")
-      end
-
-      it "sets the name to just the name" do
-        expect(cookbook_manifest_hash["name"]).to eq("tatft")
-      end
-
-      it "does not set a 'cookbook_name' field" do
-        expect(cookbook_manifest_hash).to_not have_key("cookbook_name")
-      end
-
-      it "gives the save URL" do
-        expect(cookbook_manifest.save_url).to eq("cookbook_artifacts/tatft/9e10455ce2b4a4e29424b7064b1d67a1a25c9d3b")
-      end
-
-      it "gives the force save URL" do
-        expect(cookbook_manifest.force_save_url).to eq("cookbook_artifacts/tatft/9e10455ce2b4a4e29424b7064b1d67a1a25c9d3b?force=true")
-      end
-
-    end
-  end
-
-end

data/spec/unit/cookbook_spec.rb

@@ -1,62 +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"
-
-describe Chef::CookbookVersion do
-  COOKBOOK_PATH = File.expand_path(File.join(__dir__, "..", "data", "cookbooks", "openldap"))
-
-  before(:each) do
-    @cookbook_repo = File.expand_path(File.join(__dir__, "..", "data", "cookbooks"))
-    cl = Chef::CookbookLoader.new(@cookbook_repo)
-    cl.load_cookbooks
-    @cookbook_collection = Chef::CookbookCollection.new(cl)
-    @cookbook = @cookbook_collection[:openldap]
-    @node = Chef::Node.new
-    @node.name "JuliaChild"
-    @events = Chef::EventDispatch::Dispatcher.new
-    @run_context = Chef::RunContext.new(@node, @cookbook_collection, @events)
-  end
-
-  it "should have a name" do
-    expect(@cookbook.name).to eq(:openldap)
-  end
-
-  it "should allow you to set the list of attribute files and create the mapping from short names to paths" do
-    expect(@cookbook.attribute_filenames_by_short_filename.keys.sort).to eql(%w{default smokey})
-    expect(@cookbook.attribute_filenames_by_short_filename["default"]).to eq(File.join(COOKBOOK_PATH, "attributes/default.rb"))
-    expect(@cookbook.attribute_filenames_by_short_filename["smokey"]).to eq(File.join(COOKBOOK_PATH, "attributes/smokey.rb"))
-  end
-
-  it "should allow you to set the list of recipe files and create the mapping of recipe short name to filename" do
-    expect(@cookbook.recipe_filenames_by_name.keys.sort).to eql(%w{default gigantor one return})
-    expect(@cookbook.recipe_filenames_by_name["one"]).to eq(File.join(COOKBOOK_PATH, "recipes/one.rb"))
-    expect(@cookbook.recipe_filenames_by_name["gigantor"]).to eq(File.join(COOKBOOK_PATH, "recipes/gigantor.rb"))
-  end
-
-  it "should generate a list of recipes by fully-qualified name" do
-    expect(@cookbook.fully_qualified_recipe_names.include?("openldap::one")).to eq(true)
-    expect(@cookbook.fully_qualified_recipe_names.include?("openldap::gigantor")).to eq(true)
-    expect(@cookbook.fully_qualified_recipe_names.include?("openldap::return")).to eq(true)
-  end
-
-  it "should raise an ArgumentException if you try to load a bad recipe name" do
-    expect { @cookbook.load_recipe("doesnt_exist", @node) }.to raise_error(ArgumentError)
-  end
-
-end

data/spec/unit/cookbook_uploader_spec.rb

@@ -1,205 +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_relative "../../lib/chef/cookbook_uploader"
-
-describe Chef::CookbookUploader do
-
-  let(:http_client) { double("Chef::ServerAPI") }
-  let(:cookbook_path) { File.join(CHEF_SPEC_DATA, "cookbooks") }
-
-  let(:cookbook_loader) do
-    loader = Chef::CookbookLoader.new(cookbook_path)
-    loader.load_cookbooks
-    loader.cookbooks_by_name["apache2"].identifier = apache2_identifier
-    loader.cookbooks_by_name["java"].identifier = java_identifier
-    loader
-  end
-
-  let(:apache2_identifier) { "6644e6cb2ade90b8aff2ebb44728958fbc939ebf" }
-
-  let(:apache2_cookbook) { cookbook_loader.cookbooks_by_name["apache2"] }
-
-  let(:java_identifier) { "edd40c30c4e0ebb3658abde4620597597d2e9c17" }
-
-  let(:java_cookbook) { cookbook_loader.cookbooks_by_name["java"] }
-
-  let(:cookbooks_to_upload) { [apache2_cookbook, java_cookbook] }
-
-  let(:checksums_of_cookbook_files) { apache2_cookbook.checksums.merge(java_cookbook.checksums) }
-
-  let(:checksums_set) do
-    checksums_of_cookbook_files.keys.inject({}) do |set, cksum|
-      set[cksum] = nil
-      set
-    end
-  end
-
-  let(:sandbox_commit_uri) { "https://chef.example.org/sandboxes/abc123" }
-
-  let(:policy_mode) { false }
-
-  let(:uploader) { described_class.new(cookbooks_to_upload, rest: http_client, policy_mode: policy_mode) }
-
-  before do
-    allow(Chef::Config).to receive(:cookbook_path) { cookbook_path }
-  end
-
-  it "defaults to not enabling policy mode" do
-    expect(described_class.new(cookbooks_to_upload, rest: http_client).policy_mode?).to be(false)
-  end
-
-  it "has a list of cookbooks to upload" do
-    expect(uploader.cookbooks).to eq(cookbooks_to_upload)
-  end
-
-  it "creates an HTTP client with default configuration when not initialized with one" do
-    default_http_client = double("Chef::ServerAPI")
-    expect(Chef::ServerAPI).to receive(:new).with(Chef::Config[:chef_server_url], version_class: Chef::CookbookManifestVersions).and_return(default_http_client)
-    uploader = described_class.new(cookbooks_to_upload)
-    expect(uploader.rest).to eq(default_http_client)
-  end
-
-  describe "uploading cookbooks" do
-
-    def url_for(cksum)
-      "https://storage.example.com/#{cksum}"
-    end
-
-    let(:sandbox_response) do
-      sandbox_checksums = cksums_not_on_remote.inject({}) do |cksum_map, cksum|
-        cksum_map[cksum] = { "needs_upload" => true, "url" => url_for(cksum) }
-        cksum_map
-      end
-      { "checksums" => sandbox_checksums, "uri" => sandbox_commit_uri }
-    end
-
-    def expect_sandbox_create
-      expect(http_client).to receive(:post)
-        .with("sandboxes", { checksums: checksums_set })
-        .and_return(sandbox_response)
-    end
-
-    def expect_checksum_upload
-      checksums_of_cookbook_files.each do |md5, file_path|
-        next unless cksums_not_on_remote.include?(md5)
-
-        upload_headers = {
-          "content-type" => "application/x-binary",
-          "content-md5" => an_instance_of(String),
-          "accept" => "application/json",
-        }
-
-        expect(http_client).to receive(:put)
-          .with(url_for(md5), IO.binread(file_path), upload_headers)
-
-      end
-    end
-
-    def expected_save_url(cookbook)
-      "cookbooks/#{cookbook.name}/#{cookbook.version}"
-    end
-
-    def expect_sandbox_commit
-      expect(http_client).to receive(:put).with(sandbox_commit_uri, { is_completed: true })
-    end
-
-    def expect_cookbook_create
-      cookbooks_to_upload.each do |cookbook|
-
-        expect(http_client).to receive(:put)
-          .with(expected_save_url(cookbook), cookbook)
-
-      end
-    end
-
-    context "when no files exist on the server" do
-
-      let(:cksums_not_on_remote) do
-        checksums_of_cookbook_files.keys
-      end
-
-      it "uploads all files in a sandbox transaction, then creates cookbooks on the server" do
-        expect_sandbox_create
-        expect_checksum_upload
-        expect_sandbox_commit
-        expect_cookbook_create
-
-        uploader.upload_cookbooks
-      end
-
-    end
-
-    context "when some files exist on the server" do
-
-      let(:cksums_not_on_remote) do
-        checksums_of_cookbook_files.keys[0, 1]
-      end
-
-      it "uploads all files in a sandbox transaction, then creates cookbooks on the server" do
-        expect_sandbox_create
-        expect_checksum_upload
-        expect_sandbox_commit
-        expect_cookbook_create
-
-        uploader.upload_cookbooks
-      end
-
-    end
-
-    context "when all files already exist on the server" do
-
-      let(:cksums_not_on_remote) { [] }
-
-      it "uploads all files in a sandbox transaction, then creates cookbooks on the server" do
-        expect_sandbox_create
-        expect_checksum_upload
-        expect_sandbox_commit
-        expect_cookbook_create
-
-        uploader.upload_cookbooks
-      end
-
-    end
-
-    context "when policy_mode is specified" do
-
-      let(:cksums_not_on_remote) do
-        checksums_of_cookbook_files.keys
-      end
-
-      let(:policy_mode) { true }
-
-      def expected_save_url(cookbook)
-        "cookbook_artifacts/#{cookbook.name}/#{cookbook.identifier}"
-      end
-
-      it "uploads all files in a sandbox transaction, then creates cookbooks on the server using cookbook_artifacts API" do
-        expect_sandbox_create
-        expect_checksum_upload
-        expect_sandbox_commit
-        expect_cookbook_create
-
-        uploader.upload_cookbooks
-      end
-
-    end
-  end
-
-end