chef 12.6.0-universal-mingw32 → 12.7.2-universal-mingw32

data/spec/unit/run_context/child_run_context_spec.rb

@@ -1,8 +1,8 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Tim Hinderliter (<tim@opscode.com>)
-# Author:: Christopher Walters (<cw@opscode.com>)
-# Copyright:: Copyright (c) 2008, 2010 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Tim Hinderliter (<tim@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,8 +18,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'support/lib/library_load_order'
+require "spec_helper"
+require "support/lib/library_load_order"
 
 describe Chef::RunContext::ChildRunContext do
   context "with a run context with stuff in it" do
@@ -46,14 +46,14 @@ describe Chef::RunContext::ChildRunContext do
 
       it "audits is not the same as the parent" do
         expect(child.audits.object_id).not_to eq run_context.audits.object_id
-        child.audits['hi'] = 'lo'
-        expect(child.audits['hi']).to eq('lo')
-        expect(run_context.audits['hi']).not_to eq('lo')
+        child.audits["hi"] = "lo"
+        expect(child.audits["hi"]).to eq("lo")
+        expect(run_context.audits["hi"]).not_to eq("lo")
       end
 
       it "resource_collection is not the same as the parent" do
         expect(child.resource_collection.object_id).not_to eq run_context.resource_collection.object_id
-        f = Chef::Resource::File.new('hi', child)
+        f = Chef::Resource::File.new("hi", child)
         child.resource_collection.insert(f)
         expect(child.resource_collection).to include f
         expect(run_context.resource_collection).not_to include f
@@ -61,17 +61,17 @@ describe Chef::RunContext::ChildRunContext do
 
       it "immediate_notification_collection is not the same as the parent" do
         expect(child.immediate_notification_collection.object_id).not_to eq run_context.immediate_notification_collection.object_id
-        src = Chef::Resource::File.new('hi', child)
-        dest = Chef::Resource::File.new('argh', child)
+        src = Chef::Resource::File.new("hi", child)
+        dest = Chef::Resource::File.new("argh", child)
         notification = Chef::Resource::Notification.new(dest, :create, src)
         child.notifies_immediately(notification)
-        expect(child.immediate_notification_collection['file[hi]']).to eq([notification])
-        expect(run_context.immediate_notification_collection['file[hi]']).not_to eq([notification])
+        expect(child.immediate_notification_collection["file[hi]"]).to eq([notification])
+        expect(run_context.immediate_notification_collection["file[hi]"]).not_to eq([notification])
       end
 
       it "immediate_notifications is not the same as the parent" do
-        src = Chef::Resource::File.new('hi', child)
-        dest = Chef::Resource::File.new('argh', child)
+        src = Chef::Resource::File.new("hi", child)
+        dest = Chef::Resource::File.new("argh", child)
         notification = Chef::Resource::Notification.new(dest, :create, src)
         child.notifies_immediately(notification)
         expect(child.immediate_notifications(src)).to eq([notification])
@@ -80,17 +80,17 @@ describe Chef::RunContext::ChildRunContext do
 
       it "delayed_notification_collection is not the same as the parent" do
         expect(child.delayed_notification_collection.object_id).not_to eq run_context.delayed_notification_collection.object_id
-        src = Chef::Resource::File.new('hi', child)
-        dest = Chef::Resource::File.new('argh', child)
+        src = Chef::Resource::File.new("hi", child)
+        dest = Chef::Resource::File.new("argh", child)
         notification = Chef::Resource::Notification.new(dest, :create, src)
         child.notifies_delayed(notification)
-        expect(child.delayed_notification_collection['file[hi]']).to eq([notification])
-        expect(run_context.delayed_notification_collection['file[hi]']).not_to eq([notification])
+        expect(child.delayed_notification_collection["file[hi]"]).to eq([notification])
+        expect(run_context.delayed_notification_collection["file[hi]"]).not_to eq([notification])
       end
 
       it "delayed_notifications is not the same as the parent" do
-        src = Chef::Resource::File.new('hi', child)
-        dest = Chef::Resource::File.new('argh', child)
+        src = Chef::Resource::File.new("hi", child)
+        dest = Chef::Resource::File.new("argh", child)
         notification = Chef::Resource::Notification.new(dest, :create, src)
         child.notifies_delayed(notification)
         expect(child.delayed_notifications(src)).to eq([notification])
@@ -104,7 +104,7 @@ describe Chef::RunContext::ChildRunContext do
 
       context "after load('include::default')" do
         before do
-          run_list = Chef::RunList.new('include::default').expand('_default')
+          run_list = Chef::RunList.new("include::default").expand("_default")
           # TODO not sure why we had to do this to get everything to work ...
           node.automatic_attrs[:recipes] = []
           child.load(run_list)

data/spec/unit/run_context/cookbook_compiler_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# Author:: Daniel DeLeo (<dan@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");
@@ -16,8 +16,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'support/lib/library_load_order'
+require "spec_helper"
+require "support/lib/library_load_order"
 
 # These tests rely on fixture data in spec/data/run_context/cookbooks.
 #
@@ -45,13 +45,12 @@ describe Chef::RunContext::CookbookCompiler do
   let(:cookbook_collection) { Chef::CookbookCollection.new(cookbook_loader) }
 
   # Lazy evaluation of `expansion` here is used to mutate the run list before expanding it
-  let(:run_list_expansion) { node.run_list.expand('_default') }
+  let(:run_list_expansion) { node.run_list.expand("_default") }
 
   let(:compiler) do
     Chef::RunContext::CookbookCompiler.new(run_context, run_list_expansion, events)
   end
 
-
   describe "loading attribute files" do
 
     # Attribute files in the fixture data will append their
@@ -181,6 +180,5 @@ describe Chef::RunContext::CookbookCompiler do
       expect(compiler.unreachable_cookbook?(:'circular-dep2')).to be_truthy
     end
 
-
   end
 end

data/spec/unit/run_context_spec.rb

@@ -1,8 +1,8 @@
 #
-# Author:: Adam Jacob (<adam@opscode.com>)
-# Author:: Tim Hinderliter (<tim@opscode.com>)
-# Author:: Christopher Walters (<cw@opscode.com>)
-# Copyright:: Copyright (c) 2008, 2010 Opscode, Inc.
+# Author:: Adam Jacob (<adam@chef.io>)
+# Author:: Tim Hinderliter (<tim@chef.io>)
+# Author:: Christopher Walters (<cw@chef.io>)
+# Copyright:: Copyright 2008-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -18,8 +18,8 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
-require 'support/lib/library_load_order'
+require "spec_helper"
+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")) }
@@ -57,33 +57,33 @@ describe Chef::RunContext do
     expect(run_context.node[:cookbooks]).to eql(
       {
         "circular-dep1" => {
-          "version" => "0.0.0",
+          "version" => "0.0.0"
         },
         "circular-dep2" => {
-          "version" => "0.0.0",
+          "version" => "0.0.0"
         },
         "dependency1" => {
-          "version" => "0.0.0",
+          "version" => "0.0.0"
         },
         "dependency2" => {
-          "version" => "0.0.0",
+          "version" => "0.0.0"
         },
         "include" => {
-          "version" => "0.0.0",
+          "version" => "0.0.0"
         },
         "no-default-attr" => {
-          "version" => "0.0.0",
+          "version" => "0.0.0"
         },
         "test" => {
-          "version" => "0.0.0",
+          "version" => "0.0.0"
         },
         "test-with-circular-deps" => {
-          "version" => "0.0.0",
+          "version" => "0.0.0"
         },
         "test-with-deps" => {
-          "version" => "0.0.0",
+          "version" => "0.0.0"
         },
-      }
+      },
     )
   end
 
@@ -104,7 +104,7 @@ describe Chef::RunContext do
       expect(node).to receive(:loaded_recipe).with(:test, "default")
       expect(node).to receive(:loaded_recipe).with(:test, "one")
       expect(node).to receive(:loaded_recipe).with(:test, "two")
-      run_context.load(node.run_list.expand('_default'))
+      run_context.load(node.run_list.expand("_default"))
     end
 
     it "should load all the definitions in the cookbooks for this node" do
@@ -202,7 +202,7 @@ describe Chef::RunContext do
     let(:notification) { Chef::Resource::Notification.new(nil, nil, notifying_resource) }
 
     shared_context "notifying resource is a Chef::Resource" do
-      let(:notifying_resource)  { Chef::Resource.new("gerbil") }
+      let(:notifying_resource) { Chef::Resource.new("gerbil") }
 
       it "should be keyed off the resource name" do
         run_context.send(setter, notification)
@@ -212,7 +212,7 @@ 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) {
         r = Class.new(Chef::Resource).new("guinea pig")
         r.declared_type = declared_type
         r

data/spec/unit/run_list/run_list_expansion_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2010-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,12 +16,12 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::RunList::RunListExpansion do
   before do
     @run_list = Chef::RunList.new
-    @run_list << 'recipe[lobster::mastercookbook@0.1.0]' << 'role[rage]' << 'recipe[fist@0.1]'
+    @run_list << "recipe[lobster::mastercookbook@0.1.0]" << "role[rage]" << "recipe[fist@0.1]"
     @expansion = Chef::RunList::RunListExpansion.new("_default", @run_list.run_list_items)
   end
 
@@ -43,7 +43,7 @@ describe Chef::RunList::RunListExpansion do
     end
 
     it "has not applied its roles" do
-      expect(@expansion.applied_role?('rage')).to be_falsey
+      expect(@expansion.applied_role?("rage")).to be_falsey
     end
   end
 
@@ -51,7 +51,7 @@ describe Chef::RunList::RunListExpansion do
     before do
       @rage_role = Chef::Role.new.tap do |r|
         r.name("rage")
-        r.env_run_lists('_default' => [], "prod" => ["recipe[prod-only]"])
+        r.env_run_lists("_default" => [], "prod" => ["recipe[prod-only]"])
       end
       @expansion = Chef::RunList::RunListExpansion.new("prod", @run_list.run_list_items)
       expect(@expansion).to receive(:fetch_role).and_return(@rage_role)
@@ -67,34 +67,34 @@ describe Chef::RunList::RunListExpansion do
   describe "after applying a role" do
     before do
       allow(@expansion).to receive(:fetch_role).and_return(Chef::Role.new)
-      @expansion.inflate_role('rage', "role[base]")
+      @expansion.inflate_role("rage", "role[base]")
     end
 
     it "tracks the applied role" do
-      expect(@expansion.applied_role?('rage')).to be_truthy
+      expect(@expansion.applied_role?("rage")).to be_truthy
     end
 
     it "does not inflate the role again" do
-      expect(@expansion.inflate_role('rage', "role[base]")).to be_falsey
+      expect(@expansion.inflate_role("rage", "role[base]")).to be_falsey
     end
   end
 
   describe "after expanding a run list" do
     before do
       @first_role = Chef::Role.new
-      @first_role.name('rage')
-      @first_role.run_list('role[mollusk]')
-      @first_role.default_attributes({'foo' => 'bar'})
-      @first_role.override_attributes({'baz' => 'qux'})
+      @first_role.name("rage")
+      @first_role.run_list("role[mollusk]")
+      @first_role.default_attributes({ "foo" => "bar" })
+      @first_role.override_attributes({ "baz" => "qux" })
       @second_role = Chef::Role.new
-      @second_role.name('rage')
-      @second_role.run_list('recipe[crabrevenge]')
-      @second_role.default_attributes({'foo' => 'boo'})
-      @second_role.override_attributes({'baz' => 'bux'})
+      @second_role.name("rage")
+      @second_role.run_list("recipe[crabrevenge]")
+      @second_role.default_attributes({ "foo" => "boo" })
+      @second_role.override_attributes({ "baz" => "bux" })
       allow(@expansion).to receive(:fetch_role).and_return(@first_role, @second_role)
       @expansion.expand
       @json = '{"id":"_default","run_list":[{"type":"recipe","name":"lobster::mastercookbook","version":"0.1.0",'
-      .concat(
+              .concat(
 '"skipped":false},{"type":"role","name":"rage","children":[{"type":"role","name":"mollusk","children":[],"missing":null,'
       .concat(
 '"error":null,"skipped":null},{"type":"recipe","name":"crabrevenge","version":null,"skipped":false}],"missing":null,'
@@ -109,24 +109,24 @@ describe Chef::RunList::RunListExpansion do
     end
 
     it "has the ordered list of recipes" do
-      expect(@expansion.recipes).to eq(['lobster::mastercookbook', 'crabrevenge', 'fist'])
+      expect(@expansion.recipes).to eq(["lobster::mastercookbook", "crabrevenge", "fist"])
     end
 
     it "has the merged attributes from the roles with outer roles overriding inner" do
-      expect(@expansion.default_attrs).to eq({'foo' => 'bar'})
-      expect(@expansion.override_attrs).to eq({'baz' => 'qux'})
+      expect(@expansion.default_attrs).to eq({ "foo" => "bar" })
+      expect(@expansion.override_attrs).to eq({ "baz" => "qux" })
     end
 
     it "has the list of all roles applied" do
       # this is the correct order, but 1.8 hash order is not stable
-      expect(@expansion.roles).to match_array(['rage', 'mollusk'])
+      expect(@expansion.roles).to match_array(["rage", "mollusk"])
     end
 
   end
 
   describe "after expanding a run list with a non existent role" do
     before do
-      allow(@expansion).to receive(:fetch_role) { @expansion.role_not_found('crabrevenge', "role[base]") }
+      allow(@expansion).to receive(:fetch_role) { @expansion.role_not_found("crabrevenge", "role[base]") }
       @expansion.expand
     end
 
@@ -136,7 +136,7 @@ describe Chef::RunList::RunListExpansion do
     end
 
     it "has a list of invalid role names" do
-      expect(@expansion.errors).to include('crabrevenge')
+      expect(@expansion.errors).to include("crabrevenge")
     end
 
   end

data/spec/unit/run_list/run_list_item_spec.rb

@@ -1,6 +1,6 @@
 #
-# Author:: Daniel DeLeo (<dan@opscode.com>)
-# Copyright:: Copyright (c) 2010 Opscode, Inc.
+# Author:: Daniel DeLeo (<dan@chef.io>)
+# Copyright:: Copyright 2010-2016, Chef Software Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -16,22 +16,22 @@
 # limitations under the License.
 #
 
-require 'spec_helper'
+require "spec_helper"
 
 describe Chef::RunList::RunListItem do
 
   describe "when creating from a Hash" do
     it "raises an exception when the hash doesn't have a :type key" do
-      expect {Chef::RunList::RunListItem.new(:name => "tatft")}.to raise_error(ArgumentError)
+      expect { Chef::RunList::RunListItem.new(:name => "tatft") }.to raise_error(ArgumentError)
     end
 
     it "raises an exception when the hash doesn't have an :name key" do
-      expect {Chef::RunList::RunListItem.new(:type => 'R') }.to raise_error(ArgumentError)
+      expect { Chef::RunList::RunListItem.new(:type => "R") }.to raise_error(ArgumentError)
     end
 
     it "sets the name and type as given in the hash" do
-      item = Chef::RunList::RunListItem.new(:type => 'fuuu', :name => 'uuuu')
-      expect(item.to_s).to eq('fuuu[uuuu]')
+      item = Chef::RunList::RunListItem.new(:type => "fuuu", :name => "uuuu")
+      expect(item.to_s).to eq("fuuu[uuuu]")
     end
 
   end
@@ -41,77 +41,77 @@ describe Chef::RunList::RunListItem do
       item = Chef::RunList::RunListItem.new("recipe[rage]")
       expect(item).to be_a_recipe
       expect(item).not_to be_a_role
-      expect(item.to_s).to eq('recipe[rage]')
-      expect(item.name).to eq('rage')
+      expect(item.to_s).to eq("recipe[rage]")
+      expect(item.name).to eq("rage")
     end
 
     it "parses a qualified recipe with a version" do
       item = Chef::RunList::RunListItem.new("recipe[rage@0.1.0]")
       expect(item).to be_a_recipe
       expect(item).not_to be_a_role
-      expect(item.to_s).to eq('recipe[rage@0.1.0]')
-      expect(item.name).to eq('rage')
-      expect(item.version).to eq('0.1.0')
+      expect(item.to_s).to eq("recipe[rage@0.1.0]")
+      expect(item.name).to eq("rage")
+      expect(item.version).to eq("0.1.0")
     end
 
     it "parses a qualified role" do
       item = Chef::RunList::RunListItem.new("role[fist]")
       expect(item).to be_a_role
       expect(item).not_to be_a_recipe
-      expect(item.to_s).to eq('role[fist]')
-      expect(item.name).to eq('fist')
+      expect(item.to_s).to eq("role[fist]")
+      expect(item.name).to eq("fist")
     end
 
     it "parses an unqualified recipe" do
       item = Chef::RunList::RunListItem.new("lobster")
       expect(item).to be_a_recipe
       expect(item).not_to be_a_role
-      expect(item.to_s).to eq('recipe[lobster]')
-      expect(item.name).to eq('lobster')
+      expect(item.to_s).to eq("recipe[lobster]")
+      expect(item.name).to eq("lobster")
     end
 
     it "raises an exception when the string has typo on the type part" do
-      expect {Chef::RunList::RunListItem.new("Recipe[lobster]") }.to raise_error(ArgumentError)
+      expect { Chef::RunList::RunListItem.new("Recipe[lobster]") }.to raise_error(ArgumentError)
     end
 
     it "raises an exception when the string has extra space between the type and the name" do
-      expect {Chef::RunList::RunListItem.new("recipe [lobster]") }.to raise_error(ArgumentError)
+      expect { Chef::RunList::RunListItem.new("recipe [lobster]") }.to raise_error(ArgumentError)
     end
 
     it "raises an exception when the string does not close the bracket" do
-      expect {Chef::RunList::RunListItem.new("recipe[lobster") }.to raise_error(ArgumentError)
+      expect { Chef::RunList::RunListItem.new("recipe[lobster") }.to raise_error(ArgumentError)
     end
   end
 
   describe "comparing to other run list items" do
     it "is equal to another run list item that has the same name and type" do
-      item1 = Chef::RunList::RunListItem.new('recipe[lrf]')
-      item2 = Chef::RunList::RunListItem.new('recipe[lrf]')
+      item1 = Chef::RunList::RunListItem.new("recipe[lrf]")
+      item2 = Chef::RunList::RunListItem.new("recipe[lrf]")
       expect(item1).to eq(item2)
     end
 
     it "is not equal to another run list item with the same name and different type" do
-      item1 = Chef::RunList::RunListItem.new('recipe[lrf]')
-      item2 = Chef::RunList::RunListItem.new('role[lrf]')
+      item1 = Chef::RunList::RunListItem.new("recipe[lrf]")
+      item2 = Chef::RunList::RunListItem.new("role[lrf]")
       expect(item1).not_to eq(item2)
     end
 
     it "is not equal to another run list item with the same type and different name" do
-      item1 = Chef::RunList::RunListItem.new('recipe[lrf]')
-      item2 = Chef::RunList::RunListItem.new('recipe[lobsterragefist]')
+      item1 = Chef::RunList::RunListItem.new("recipe[lrf]")
+      item2 = Chef::RunList::RunListItem.new("recipe[lobsterragefist]")
       expect(item1).not_to eq(item2)
     end
 
     it "is not equal to another run list item with the same name and type but different version" do
-      item1 = Chef::RunList::RunListItem.new('recipe[lrf,0.1.0]')
-      item2 = Chef::RunList::RunListItem.new('recipe[lrf,0.2.0]')
+      item1 = Chef::RunList::RunListItem.new("recipe[lrf,0.1.0]")
+      item2 = Chef::RunList::RunListItem.new("recipe[lrf,0.2.0]")
       expect(item1).not_to eq(item2)
     end
   end
 
   describe "comparing to strings" do
     it "is equal to a string if that string matches its to_s representation" do
-      expect(Chef::RunList::RunListItem.new('recipe[lrf]')).to eq('recipe[lrf]')
+      expect(Chef::RunList::RunListItem.new("recipe[lrf]")).to eq("recipe[lrf]")
     end
   end
 end