chef 12.13.37-universal-mingw32 → 12.14.60-universal-mingw32

data/spec/unit/resource_definition_spec.rb

@@ -53,26 +53,26 @@ describe Chef::ResourceDefinition do
   end
 
   it "should accept a new definition with a symbol for a name" do
-    expect {
+    expect do
       defn.define :smoke do
       end
-    }.not_to raise_error
-    expect {
+    end.not_to raise_error
+    expect do
       defn.define "george washington" do
       end
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
     expect(defn.name).to eql(:smoke)
   end
 
   it "should accept a new definition with a hash" do
-    expect {
+    expect do
       defn.define :smoke, :cigar => "cuban", :cigarette => "marlboro" do
       end
-    }.not_to raise_error
+    end.not_to raise_error
   end
 
   it "should expose the prototype hash params in the params hash" do
-    defn.define :smoke, :cigar => "cuban", :cigarette => "marlboro" do; end
+    defn.define(:smoke, :cigar => "cuban", :cigarette => "marlboro") {}
     expect(defn.params[:cigar]).to eql("cuban")
     expect(defn.params[:cigarette]).to eql("marlboro")
   end
@@ -91,16 +91,16 @@ describe Chef::ResourceDefinition do
   end
 
   it "should raise an exception if prototype_params is not a hash" do
-    expect {
+    expect do
       defn.define :monkey, Array.new do
       end
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should raise an exception if define is called without a block" do
-    expect {
+    expect do
       defn.define :monkey
-    }.to raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it "should load a description from a file" do

data/spec/unit/resource_reporter_spec.rb

@@ -664,9 +664,9 @@ describe Chef::ResourceReporter do
 
       it "fails the run and prints an message about the error" do
         expect(Chef::Log).to receive(:error).with(/500/)
-        expect {
+        expect do
           @resource_reporter.run_started(@run_status)
-        }.to raise_error(Net::HTTPServerException)
+        end.to raise_error(Net::HTTPServerException)
       end
     end
 
@@ -749,9 +749,9 @@ describe Chef::ResourceReporter do
       it "should raise if an unkwown error happens" do
         allow(@rest_client).to receive(:raw_request).and_raise(Exception.new)
 
-        expect {
+        expect do
           @resource_reporter.post_reporting_data
-        }.to raise_error(Exception)
+        end.to raise_error(Exception)
       end
     end
   end

data/spec/unit/resource_resolver_spec.rb

@@ -20,11 +20,11 @@ require "spec_helper"
 require "chef/resource_resolver"
 
 describe Chef::ResourceResolver do
-  it '#resolve' do
+  it "#resolve" do
     expect(described_class.resolve(:execute)).to eq(Chef::Resource::Execute)
   end
 
-  it '#list' do
+  it "#list" do
     expect(described_class.list(:package)).to_not be_empty
   end
 
@@ -33,19 +33,19 @@ describe Chef::ResourceResolver do
       described_class.new(Chef::Node.new, "execute")
     end
 
-    it '#resolve' do
+    it "#resolve" do
       expect(resolver.resolve).to eq Chef::Resource::Execute
     end
 
-    it '#list' do
+    it "#list" do
       expect(resolver.list).to eq [ Chef::Resource::Execute ]
     end
 
-    it '#provided_by? returns true when resource class is in the list' do
+    it "#provided_by? returns true when resource class is in the list" do
       expect(resolver.provided_by?(Chef::Resource::Execute)).to be_truthy
     end
 
-    it '#provided_by? returns false when resource class is not in the list' do
+    it "#provided_by? returns false when resource class is not in the list" do
       expect(resolver.provided_by?(Chef::Resource::File)).to be_falsey
     end
   end

data/spec/unit/resource_spec.rb

@@ -95,7 +95,7 @@ describe Chef::Resource do
   end
 
   describe "when an identity attribute has been declared" do
-    let(:file_resource) {
+    let(:file_resource) do
       file_resource_class = Class.new(Chef::Resource) do
         identity_attr :path
         attr_accessor :path
@@ -104,7 +104,7 @@ describe Chef::Resource do
       file_resource = file_resource_class.new("identity-attr-test")
       file_resource.path = "/tmp/foo.txt"
       file_resource
-    }
+    end
 
     it "gives the value of its identity attribute" do
       expect(file_resource.identity).to eq("/tmp/foo.txt")
@@ -140,7 +140,7 @@ describe Chef::Resource do
   end
 
   describe "when a set of state attributes has been declared" do
-    let(:file_resource) {
+    let(:file_resource) do
       file_resource_class = Class.new(Chef::Resource) do
 
         state_attrs :checksum, :owner, :group, :mode
@@ -157,7 +157,7 @@ describe Chef::Resource do
       file_resource.group = "wheel"
       file_resource.mode = "0644"
       file_resource
-    }
+    end
 
     it "describes its state" do
       resource_state = file_resource.state
@@ -169,15 +169,35 @@ describe Chef::Resource do
     end
   end
 
+  describe "#state_for_resource_reporter" do
+    context "when a property is marked as sensitive" do
+      it "suppresses the sensitive property's value" do
+        resource_class = Class.new(Chef::Resource) { property :foo, String, sensitive: true }
+        resource = resource_class.new("sensitive_property_tests")
+        resource.foo = "some value"
+        expect(resource.state_for_resource_reporter[:foo]).to eq("*sensitive value suppressed*")
+      end
+    end
+
+    context "when a property is not marked as sensitive" do
+      it "does not suppress the property's value" do
+        resource_class = Class.new(Chef::Resource) { property :foo, String }
+        resource = resource_class.new("sensitive_property_tests")
+        resource.foo = "some value"
+        expect(resource.state_for_resource_reporter[:foo]).to eq("some value")
+      end
+    end
+  end
+
   describe "load_from" do
-    let(:prior_resource) {
+    let(:prior_resource) do
       prior_resource = Chef::Resource.new("funk")
       prior_resource.supports(:funky => true)
       prior_resource.source_line
       prior_resource.allowed_actions << :funkytown
       prior_resource.action(:funkytown)
       prior_resource
-    }
+    end
     before(:each) do
       resource.allowed_actions << :funkytown
       run_context.resource_collection << prior_resource
@@ -236,9 +256,9 @@ describe Chef::Resource do
 
     it "should raise an exception if told to act in other than :delay or :immediate(ly)" do
       run_context.resource_collection << Chef::Resource::ZenMaster.new("coffee")
-      expect {
+      expect do
         resource.notifies :reload, run_context.resource_collection.find(:zen_master => "coffee"), :someday
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should allow multiple notified resources appear in the actions hash" do
@@ -503,12 +523,12 @@ describe Chef::Resource do
   end
 
   describe "retries" do
-    let(:retriable_resource) {
+    let(:retriable_resource) do
       retriable_resource = Chef::Resource::Cat.new("precious", run_context)
       retriable_resource.provider = Chef::Provider::SnakeOil
       retriable_resource.action = :purr
       retriable_resource
-    }
+    end
 
     before do
       node.automatic_attrs[:platform] = "fubuntu"
@@ -563,11 +583,11 @@ describe Chef::Resource do
     end
 
     it "warns when setting provider_base" do
-      expect {
+      expect do
         class OverrideProviderBaseTest2 < Chef::Resource
           provider_base Chef::Provider::Package
         end
-      }.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
+      end.to raise_error(Chef::Exceptions::DeprecatedFeatureError)
     end
 
   end
@@ -607,11 +627,11 @@ describe Chef::Resource do
   end
 
   describe "when invoking its action" do
-    let(:resource) {
+    let(:resource) do
       resource = Chef::Resource.new("provided", run_context)
       resource.provider = Chef::Provider::SnakeOil
       resource
-    }
+    end
     before do
       node.automatic_attrs[:platform] = "fubuntu"
       node.automatic_attrs[:platform_version] = "10.04"
@@ -797,11 +817,11 @@ describe Chef::Resource do
   end
 
   describe "when resource action is :nothing" do
-    let(:resource1) {
+    let(:resource1) do
       resource1 = Chef::Resource::Cat.new("sugar", run_context)
       resource1.action = :nothing
       resource1
-    }
+    end
     before do
       node.automatic_attrs[:platform] = "fubuntu"
       node.automatic_attrs[:platform_version] = "10.04"

data/spec/unit/run_context/child_run_context_spec.rb

@@ -24,16 +24,16 @@ require "support/lib/library_load_order"
 describe Chef::RunContext::ChildRunContext do
   context "with a run context with stuff in it" do
     let(:chef_repo_path) { File.expand_path(File.join(CHEF_SPEC_DATA, "run_context", "cookbooks")) }
-    let(:cookbook_collection) {
+    let(:cookbook_collection) do
       cl = Chef::CookbookLoader.new(chef_repo_path)
       cl.load_cookbooks
       Chef::CookbookCollection.new(cl)
-    }
-    let(:node) {
+    end
+    let(:node) do
       node = Chef::Node.new
       node.run_list << "test" << "test::one" << "test::two"
       node
-    }
+    end
     let(:events) { Chef::EventDispatch::Dispatcher.new }
     let(:run_context) { Chef::RunContext.new(node, cookbook_collection, events) }
 

data/spec/unit/run_context/cookbook_compiler_spec.rb

@@ -158,7 +158,49 @@ describe Chef::RunContext::CookbookCompiler do
   end
 
   describe "loading recipes" do
-    # Tests for this behavior are in RunContext's tests
+    # Additional tests for this behavior are in RunContext's tests
+
+    describe "event dispatch" do
+      let(:recipe) { "dependency1::default" }
+      let(:recipe_path) do
+        File.expand_path("../../../data/run_context/cookbooks/dependency1/recipes/default.rb", __FILE__).tap do |path|
+          path.gsub!(File::SEPARATOR, File::ALT_SEPARATOR) if File::ALT_SEPARATOR
+        end
+      end
+      before do
+        node.run_list(recipe)
+      end
+      subject { compiler.compile_recipes }
+
+      it "dispatches normally" do
+        allow(run_context).to receive(:load_recipe)
+        expect(events).to receive(:recipe_load_start).with(1)
+        expect(events).to receive(:recipe_file_loaded).with(recipe_path, "dependency1::default")
+        expect(events).to receive(:recipe_load_complete).with(no_args)
+        subject
+      end
+
+      it "dispatches when a recipe is not found" do
+        exc = Chef::Exceptions::RecipeNotFound.new
+        allow(run_context).to receive(:load_recipe).and_raise(exc)
+        expect(events).to receive(:recipe_load_start).with(1)
+        expect(events).to_not receive(:recipe_file_loaded)
+        expect(events).to receive(:recipe_not_found).with(exc)
+        expect(events).to_not receive(:recipe_load_complete)
+        expect { subject }.to raise_error(exc)
+      end
+
+      it "dispatches when a recipe has an error" do
+        exc = ArgumentError.new
+        allow(run_context).to receive(:load_recipe).and_raise(exc)
+        expect(events).to receive(:recipe_load_start).with(1)
+        expect(events).to_not receive(:recipe_file_loaded)
+        expect(events).to receive(:recipe_file_load_failed).with(recipe_path, exc, "dependency1::default")
+        expect(events).to_not receive(:recipe_load_complete)
+        expect { subject }.to raise_error(exc)
+      end
+    end
+
   end
 
   describe "listing cookbook order" do

data/spec/unit/run_context_spec.rb

@@ -23,16 +23,16 @@ require "support/lib/library_load_order"
 
 describe Chef::RunContext do
   let(:chef_repo_path) { File.expand_path(File.join(CHEF_SPEC_DATA, "run_context", "cookbooks")) }
-  let(:cookbook_collection) {
+  let(:cookbook_collection) do
     cl = Chef::CookbookLoader.new(chef_repo_path)
     cl.load_cookbooks
     Chef::CookbookCollection.new(cl)
-  }
-  let(:node) {
+  end
+  let(:node) do
     node = Chef::Node.new
     node.run_list << "test" << "test::one" << "test::two"
     node
-  }
+  end
   let(:events) { Chef::EventDispatch::Dispatcher.new }
   let(:run_context) { Chef::RunContext.new(node, cookbook_collection, events) }
 
@@ -151,13 +151,13 @@ describe Chef::RunContext do
 
   describe "querying the contents of cookbooks" do
     let(:chef_repo_path) { File.expand_path(File.join(CHEF_SPEC_DATA, "cookbooks")) }
-    let(:node) {
+    let(:node) do
       node = Chef::Node.new
       node.normal[:platform] = "ubuntu"
       node.normal[:platform_version] = "13.04"
       node.name("testing")
       node
-    }
+    end
 
     it "queries whether a given cookbook has a specific template" do
       expect(run_context).to have_template_in_cookbook("openldap", "test.erb")
@@ -212,11 +212,11 @@ describe Chef::RunContext do
 
     shared_context "notifying resource is a subclass of Chef::Resource" do
       let(:declared_type) { :alpaca }
-      let(:notifying_resource) {
+      let(:notifying_resource) do
         r = Class.new(Chef::Resource).new("guinea pig")
         r.declared_type = declared_type
         r
-      }
+      end
 
       it "should be keyed off the resource declared key" do
         run_context.send(setter, notification)

data/spec/unit/run_list/run_list_expansion_spec.rb

@@ -104,8 +104,8 @@ describe Chef::RunList::RunListExpansion do
     end
 
     it "produces json tree upon tracing expansion" do
-      jsonRunList = @expansion.to_json
-      expect(jsonRunList).to eq(@json)
+      json_run_list = @expansion.to_json
+      expect(json_run_list).to eq(@json)
     end
 
     it "has the ordered list of recipes" do

data/spec/unit/runner_spec.rb

@@ -392,12 +392,12 @@ Multiple failures occurred:
     it "should resolve resource references in notifications when resources are defined lazily" do
       first_resource.action = :nothing
 
-      lazy_resources = lambda {
+      lazy_resources = lambda do
         last_resource = Chef::Resource::Cat.new("peanut", run_context)
         run_context.resource_collection << last_resource
         last_resource.notifies(:purr, first_resource.to_s, :delayed)
         last_resource.action = :purr
-      }
+      end
       second_resource = Chef::Resource::RubyBlock.new("myblock", run_context)
       run_context.resource_collection << second_resource
       second_resource.block { lazy_resources.call }

data/spec/unit/search/query_spec.rb

@@ -27,13 +27,13 @@ describe Chef::Search::Query do
     let(:query_string) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0" }
     let(:server_url) { "https://api.opscode.com/organizations/opscode/nodes" }
     let(:args) { { filter_key => filter_hash } }
-    let(:filter_hash) {
+    let(:filter_hash) do
       {
         "env" => [ "chef_environment" ],
         "ruby_plat" => %w{languages ruby platform},
       }
-    }
-    let(:response) {
+    end
+    let(:response) do
       {
         "rows" => [
           { "url" => "#{server_url}/my-name-is-node",
@@ -64,15 +64,15 @@ describe Chef::Search::Query do
         "start" => 0,
         "total" => 4,
       }
-    }
-    let(:response_rows) {
+    end
+    let(:response_rows) do
       [
         { "env" => "elysium", "ruby_plat" => "nudibranch" },
         { "env" => "hades", "ruby_plat" => "i386-mingw32" },
         { "env" => "elysium", "ruby_plat" => "centos" },
         { "env" => "moon", "ruby_plat" => "solaris2" },
       ]
-    }
+    end
   end
 
   before(:each) do
@@ -86,7 +86,8 @@ describe Chef::Search::Query do
     let(:query_string_with_rows) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=0&rows=4" }
     let(:query_string_continue_with_rows) { "search/node?q=platform:rhel&sort=X_CHEF_id_CHEF_X%20asc&start=4&rows=4" }
 
-    let(:response) { {
+    let(:response) do
+      {
       "rows" => [
         { "name" => "my-name-is-node",
           "chef_environment" => "elysium",
@@ -147,28 +148,28 @@ describe Chef::Search::Query do
       ],
       "start" => 0,
       "total" => 4,
-    } }
+    } end
 
-    let(:big_response) {
+    let(:big_response) do
       r = response.dup
       r["total"] = 8
       r
-    }
+    end
 
-    let(:big_response_empty) {
+    let(:big_response_empty) do
       {
         "start" => 0,
         "total" => 8,
         "rows" => [],
       }
-    }
+    end
 
-    let(:big_response_end) {
+    let(:big_response_end) do
       r = response.dup
       r["start"] = 4
       r["total"] = 8
       r
-    }
+    end
 
     it "accepts a type as the first argument" do
       expect { query.search("node") }.not_to raise_error