chef 18.6.2-universal-mingw-ucrt

data/spec/unit/cookbook_manifest_spec.rb

@@ -0,0 +1,228 @@
+#
+# 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

@@ -0,0 +1,62 @@
+#
+# 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

@@ -0,0 +1,205 @@
+#
+# 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