chef 12.10.24 → 12.11.18

data/spec/unit/chef_fs/config_spec.rb

@@ -103,4 +103,133 @@ describe Chef::ChefFS::Config 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/file_system/repository/base_file_spec.rb

@@ -47,7 +47,7 @@ describe Chef::ChefFS::FileSystem::Repository::BaseFile do
   end
 
   context "#is_json_file?" do
-    it "returns false when the file is not json" do
+    it "returns false when the file is not json", pending: "We assume that everything is ruby or JSON" do
       file = described_class.new("test_file.dpkg", parent)
       expect(file.is_json_file?).to be_falsey
     end
@@ -63,11 +63,16 @@ describe Chef::ChefFS::FileSystem::Repository::BaseFile do
       expect(file.name_valid?).to be_falsey
     end
 
-    it "rejects non json files" do
+    it "rejects non json files", pending: "We assume that everything is ruby or JSON" do
       file = described_class.new("test_file.dpkg", parent)
       expect(file.name_valid?).to be_falsey
     end
 
+    it "allows ruby files" do
+      file = described_class.new("test_file.rb", parent)
+      expect(file.name_valid?).to be_truthy
+    end
+
     it "allows correctly named files" do
       expect(file.name_valid?).to be_truthy
     end
@@ -105,14 +110,7 @@ describe Chef::ChefFS::FileSystem::Repository::BaseFile do
 
   context "#write" do
     context "minimises a json object" do
-      it "not if pretty json is off" do
-        expect(file).to_not receive(:minimize)
-        file.write(content)
-      end
-
-      it "not if it's not a json file" do
-        file = described_class.new("test_file.dpkg", parent)
-        file.write_pretty_json = true
+      it "unless pretty json is off" do
         expect(file).to_not receive(:minimize)
         file.write(content)
       end

data/spec/unit/client_spec.rb

@@ -462,7 +462,7 @@ describe Chef::Client do
 
   describe "assert_cookbook_path_not_empty" do
     before do
-      Chef::Config[:solo] = true
+      Chef::Config[:solo_legacy_mode] = true
       Chef::Config[:cookbook_path] = ["/path/to/invalid/cookbook_path"]
     end
 

data/spec/unit/config_fetcher_spec.rb

@@ -58,7 +58,7 @@ describe Chef::ConfigFetcher do
             and_return(invalid_json)
 
           expect(Chef::Application).to receive(:fatal!).
-            with(invalid_json_error_regex, 2)
+            with(invalid_json_error_regex, Chef::Exceptions::DeprecatedExitCode.new)
           fetcher.fetch_json
         end
       end
@@ -104,7 +104,7 @@ describe Chef::ConfigFetcher do
               with("").and_return(invalid_json)
 
             expect(Chef::Application).to receive(:fatal!).
-              with(invalid_json_error_regex, 2)
+              with(invalid_json_error_regex, Chef::Exceptions::DeprecatedExitCode.new)
             fetcher.fetch_json
           end
         end

data/spec/unit/cookbook/synchronizer_spec.rb

@@ -50,7 +50,7 @@ describe Chef::CookbookCacheCleaner do
     end
 
     it "does not remove anything on chef-solo" do
-      Chef::Config[:solo] = true
+      Chef::Config[:solo_legacy_mode] = true
       allow(cleaner.cache).to receive(:find).and_return(%w{cookbooks/valid1/recipes/default.rb cookbooks/valid2/recipes/default.rb})
       expect(cleaner.cache).not_to receive(:delete)
       cleaner.cleanup_file_cache

data/spec/unit/data_bag_item_spec.rb

@@ -365,11 +365,11 @@ describe Chef::DataBagItem do
 
     describe "in solo mode" do
       before do
-        Chef::Config[:solo] = true
+        Chef::Config[:solo_legacy_mode] = true
       end
 
       after do
-        Chef::Config[:solo] = false
+        Chef::Config[:solo_legacy_mode] = false
       end
 
       it "converts the raw data to a data bag item" do

data/spec/unit/data_bag_spec.rb

@@ -143,13 +143,13 @@ describe Chef::DataBag do
 
     shared_examples_for "data bag in solo mode" do |data_bag_path|
       before do
-        Chef::Config[:solo] = true
+        Chef::Config[:solo_legacy_mode] = true
         Chef::Config[:data_bag_path] = data_bag_path
         @paths = Array(data_bag_path)
       end
 
       after do
-        Chef::Config[:solo] = false
+        Chef::Config[:solo_legacy_mode] = false
       end
 
       it "should get the data bag from the data_bag_path" do

data/spec/unit/data_collector/messages/helpers_spec.rb

@@ -0,0 +1,190 @@
+#
+# Author:: Adam Leff (<adamleff@chef.io)
+#
+# Copyright:: Copyright 2012-2016, 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/data_collector/messages/helpers"
+
+class TestMessage
+  extend Chef::DataCollector::Messages::Helpers
+end
+
+describe Chef::DataCollector::Messages::Helpers do
+  describe '#organization' do
+    context "when the run is a solo run" do
+      it "returns the data collector organization" do
+        allow(TestMessage).to receive(:solo_run?).and_return(true)
+        expect(TestMessage).to receive(:data_collector_organization).and_return("org1")
+        expect(TestMessage.organization).to eq("org1")
+      end
+    end
+
+    context "when the run is not a solo run" do
+      it "returns the data collector organization" do
+        allow(TestMessage).to receive(:solo_run?).and_return(false)
+        expect(TestMessage).to receive(:chef_server_organization).and_return("org2")
+        expect(TestMessage.organization).to eq("org2")
+      end
+    end
+  end
+
+  describe '#data_collector_organization' do
+    context "when the org is specified in the config" do
+      it "returns the org from the config" do
+        Chef::Config[:data_collector][:organization] = "org1"
+        expect(TestMessage.data_collector_organization).to eq("org1")
+      end
+    end
+
+    context "when the org is not specified in the config" do
+      it "returns the default chef_solo org" do
+        expect(TestMessage.data_collector_organization).to eq("chef_solo")
+      end
+    end
+  end
+
+  describe '#chef_server_organization' do
+    context "when the URL is properly formatted" do
+      it "returns the org from the parsed URL" do
+        Chef::Config[:chef_server_url] = "http://mycompany.com/organizations/myorg"
+        expect(TestMessage.chef_server_organization).to eq("myorg")
+      end
+    end
+
+    context "when the URL is not properly formatted" do
+      it "returns unknown_organization" do
+        Chef::Config[:chef_server_url] = "http://mycompany.com/what/url/is/this"
+        expect(TestMessage.chef_server_organization).to eq("unknown_organization")
+      end
+    end
+  end
+
+  describe '#collector_source' do
+    context "when the run is a solo run" do
+      it "returns chef_solo" do
+        allow(TestMessage).to receive(:solo_run?).and_return(true)
+        expect(TestMessage.collector_source).to eq("chef_solo")
+      end
+    end
+
+    context "when the run is not a solo run" do
+      it "returns chef_client" do
+        allow(TestMessage).to receive(:solo_run?).and_return(false)
+        expect(TestMessage.collector_source).to eq("chef_client")
+      end
+    end
+  end
+
+  describe '#solo_run?' do
+    context "when :solo is set in Chef::Config" do
+      it "returns true" do
+        Chef::Config[:solo] = true
+        Chef::Config[:local_mode] = nil
+        expect(TestMessage.solo_run?).to be_truthy
+      end
+    end
+
+    context "when :local_mode is set in Chef::Config" do
+      it "returns true" do
+        Chef::Config[:solo] = nil
+        Chef::Config[:local_mode] = true
+        expect(TestMessage.solo_run?).to be_truthy
+      end
+    end
+
+    context "when neither :solo or :local_mode is set in Chef::Config" do
+      it "returns false" do
+        Chef::Config[:solo] = nil
+        Chef::Config[:local_mode] = nil
+        expect(TestMessage.solo_run?).to be_falsey
+      end
+    end
+  end
+
+  describe '#node_uuid' do
+    context "when the node UUID can be read" do
+      it "returns the read-in node UUID" do
+        allow(TestMessage).to receive(:read_node_uuid).and_return("read_uuid")
+        expect(TestMessage.node_uuid).to eq("read_uuid")
+      end
+    end
+
+    context "when the node UUID cannot be read" do
+      it "generated a new node UUID" do
+        allow(TestMessage).to receive(:read_node_uuid).and_return(nil)
+        allow(TestMessage).to receive(:generate_node_uuid).and_return("generated_uuid")
+        expect(TestMessage.node_uuid).to eq("generated_uuid")
+      end
+    end
+  end
+
+  describe '#generate_node_uuid' do
+    it "generates a new UUID, stores it, and returns it" do
+      expect(SecureRandom).to receive(:uuid).and_return("generated_uuid")
+      expect(TestMessage).to receive(:update_metadata).with("node_uuid", "generated_uuid")
+      expect(TestMessage.generate_node_uuid).to eq("generated_uuid")
+    end
+  end
+
+  describe '#read_node_uuid' do
+    it "reads the node UUID from metadata" do
+      expect(TestMessage).to receive(:metadata).and_return({ "node_uuid" => "read_uuid" })
+      expect(TestMessage.read_node_uuid).to eq("read_uuid")
+    end
+  end
+
+  describe "metadata" do
+    let(:metadata_filename) { "fake_metadata_file.json" }
+
+    before do
+      allow(TestMessage).to receive(:metadata_filename).and_return(metadata_filename)
+    end
+
+    context "when the metadata file exists" do
+      it "returns the contents of the metadata file" do
+        expect(Chef::FileCache).to receive(:load).with(metadata_filename).and_return('{"foo":"bar"}')
+        expect(TestMessage.metadata["foo"]).to eq("bar")
+      end
+    end
+
+    context "when the metadata file does not exist" do
+      it "returns an empty hash" do
+        expect(Chef::FileCache).to receive(:load).with(metadata_filename).and_raise(Chef::Exceptions::FileNotFound)
+        expect(TestMessage.metadata).to eq({})
+      end
+    end
+  end
+
+  describe '#update_metadata' do
+    let(:metadata) { double("metadata") }
+
+    it "updates the file" do
+      allow(TestMessage).to receive(:metadata_filename).and_return("fake_metadata_file.json")
+      allow(TestMessage).to receive(:metadata).and_return(metadata)
+      expect(metadata).to receive(:[]=).with("new_key", "new_value")
+      expect(metadata).to receive(:to_json).and_return("metadata_json")
+      expect(Chef::FileCache).to receive(:store).with(
+        "fake_metadata_file.json",
+        "metadata_json",
+        0644
+      )
+
+      TestMessage.update_metadata("new_key", "new_value")
+    end
+  end
+end

data/spec/unit/data_collector/messages_spec.rb

@@ -0,0 +1,207 @@
+#
+# Author:: Adam Leff (<adamleff@chef.io)
+#
+# Copyright:: Copyright 2012-2016, 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/data_collector/messages/helpers"
+
+describe Chef::DataCollector::Messages do
+  describe '#run_start_message' do
+    let(:run_status) { Chef::RunStatus.new(Chef::Node.new, Chef::EventDispatch::Dispatcher.new) }
+    let(:required_fields) do
+      %w{
+        chef_server_fqdn
+        entity_uuid
+        id
+        message_version
+        message_type
+        node_name
+        organization_name
+        run_id
+        source
+        start_time
+      }
+    end
+    let(:optional_fields) { [] }
+
+    before do
+      allow(run_status).to receive(:start_time).and_return(Time.now)
+    end
+
+    it "is not missing any required fields" do
+      missing_fields = required_fields.select do |key|
+        !Chef::DataCollector::Messages.run_start_message(run_status).key?(key)
+      end
+
+      expect(missing_fields).to eq([])
+    end
+
+    it "does not have any extra fields" do
+      extra_fields = Chef::DataCollector::Messages.run_start_message(run_status).keys.select do |key|
+        !required_fields.include?(key) && !optional_fields.include?(key)
+      end
+
+      expect(extra_fields).to eq([])
+    end
+  end
+
+  describe '#run_end_message' do
+    let(:run_status)    { Chef::RunStatus.new(Chef::Node.new, Chef::EventDispatch::Dispatcher.new) }
+    let(:resource)      { double("resource", for_json: "resource_data") }
+    let(:reporter_data) do
+      {
+        run_status: run_status,
+        updated_resources: [resource],
+      }
+    end
+
+    before do
+      allow(run_status).to receive(:start_time).and_return(Time.now)
+      allow(run_status).to receive(:end_time).and_return(Time.now)
+    end
+
+    context "when the run was successful" do
+      let(:required_fields) do
+        %w{
+          chef_server_fqdn
+          entity_uuid
+          id
+          end_time
+          expanded_run_list
+          message_type
+          message_version
+          node_name
+          organization_name
+          resources
+          run_id
+          run_list
+          source
+          start_time
+          status
+          total_resource_count
+          updated_resource_count
+        }
+      end
+      let(:optional_fields) { %w{error} }
+
+      before do
+        allow(run_status).to receive(:exception).and_return(nil)
+      end
+
+      it "is not missing any required fields" do
+        missing_fields = required_fields.select do |key|
+          !Chef::DataCollector::Messages.run_end_message(reporter_data).key?(key)
+        end
+        expect(missing_fields).to eq([])
+      end
+
+      it "does not have any extra fields" do
+        extra_fields = Chef::DataCollector::Messages.run_end_message(reporter_data).keys.select do |key|
+          !required_fields.include?(key) && !optional_fields.include?(key)
+        end
+        expect(extra_fields).to eq([])
+      end
+    end
+
+    context "when the run was not successful" do
+      let(:required_fields) do
+        %w{
+          chef_server_fqdn
+          entity_uuid
+          id
+          end_time
+          error
+          expanded_run_list
+          message_type
+          message_version
+          node_name
+          organization_name
+          resources
+          run_id
+          run_list
+          source
+          start_time
+          status
+          total_resource_count
+          updated_resource_count
+        }
+      end
+      let(:optional_fields) { [] }
+
+      before do
+        allow(run_status).to receive(:exception).and_return(RuntimeError.new("an error happened"))
+      end
+
+      it "is not missing any required fields" do
+        missing_fields = required_fields.select do |key|
+          !Chef::DataCollector::Messages.run_end_message(reporter_data).key?(key)
+        end
+        expect(missing_fields).to eq([])
+      end
+
+      it "does not have any extra fields" do
+        extra_fields = Chef::DataCollector::Messages.run_end_message(reporter_data).keys.select do |key|
+          !required_fields.include?(key) && !optional_fields.include?(key)
+        end
+        expect(extra_fields).to eq([])
+      end
+    end
+  end
+
+  describe '#node_update_message' do
+    let(:run_status) { Chef::RunStatus.new(Chef::Node.new, Chef::EventDispatch::Dispatcher.new) }
+
+    let(:required_fields) do
+      %w{
+        entity_name
+        entity_type
+        entity_uuid
+        id
+        message_type
+        message_version
+        organization_name
+        recorded_at
+        remote_hostname
+        requestor_name
+        requestor_type
+        run_id
+        service_hostname
+        source
+        task
+        user_agent
+      }
+    end
+    let(:optional_fields) { %w{data} }
+
+    it "is not missing any required fields" do
+      missing_fields = required_fields.select do |key|
+        !Chef::DataCollector::Messages.node_update_message(run_status).key?(key)
+      end
+
+      expect(missing_fields).to eq([])
+    end
+
+    it "does not have any extra fields" do
+      extra_fields = Chef::DataCollector::Messages.node_update_message(run_status).keys.select do |key|
+        !required_fields.include?(key) && !optional_fields.include?(key)
+      end
+
+      expect(extra_fields).to eq([])
+    end
+  end
+end