chef 14.2.0-universal-mingw32 → 14.3.37-universal-mingw32

data/spec/unit/role_spec.rb

@@ -104,12 +104,12 @@ describe Chef::Role do
 
   describe "default_attributes" do
     it "should let you set the default attributes hash explicitly" do
-      expect(@role.default_attributes({ :one => "two" })).to eq({ :one => "two" })
+      expect(@role.default_attributes({ one: "two" })).to eq({ one: "two" })
     end
 
     it "should let you return the default attributes hash" do
-      @role.default_attributes({ :one => "two" })
-      expect(@role.default_attributes).to eq({ :one => "two" })
+      @role.default_attributes({ one: "two" })
+      expect(@role.default_attributes).to eq({ one: "two" })
     end
 
     it "should throw an ArgumentError if we aren't a kind of hash" do
@@ -119,12 +119,12 @@ describe Chef::Role do
 
   describe "override_attributes" do
     it "should let you set the override attributes hash explicitly" do
-      expect(@role.override_attributes({ :one => "two" })).to eq({ :one => "two" })
+      expect(@role.override_attributes({ one: "two" })).to eq({ one: "two" })
     end
 
     it "should let you return the override attributes hash" do
-      @role.override_attributes({ :one => "two" })
-      expect(@role.override_attributes).to eq({ :one => "two" })
+      @role.override_attributes({ one: "two" })
+      expect(@role.override_attributes).to eq({ one: "two" })
     end
 
     it "should throw an ArgumentError if we aren't a kind of hash" do
@@ -137,15 +137,15 @@ describe Chef::Role do
       @role.name("mars_volta")
       @role.description("Great band!")
       @role.run_list("one", "two", "role[a]")
-      @role.default_attributes({ :el_groupo => "nuevo" })
-      @role.override_attributes({ :deloused => "in the comatorium" })
+      @role.default_attributes({ el_groupo: "nuevo" })
+      @role.override_attributes({ deloused: "in the comatorium" })
 
       @example = Chef::Role.new
       @example.name("newname")
       @example.description("Really Great band!")
       @example.run_list("alpha", "bravo", "role[alpha]")
-      @example.default_attributes({ :el_groupo => "nuevo dos" })
-      @example.override_attributes({ :deloused => "in the comatorium XOXO" })
+      @example.default_attributes({ el_groupo: "nuevo dos" })
+      @example.override_attributes({ deloused: "in the comatorium XOXO" })
     end
 
     it "should update all fields except for name" do
@@ -158,13 +158,13 @@ describe Chef::Role do
     end
   end
 
-  describe "when serialized as JSON", :json => true do
+  describe "when serialized as JSON", json: true do
     before(:each) do
       @role.name("mars_volta")
       @role.description("Great band!")
       @role.run_list("one", "two", "role[a]")
-      @role.default_attributes({ :el_groupo => "nuevo" })
-      @role.override_attributes({ :deloused => "in the comatorium" })
+      @role.default_attributes({ el_groupo: "nuevo" })
+      @role.override_attributes({ deloused: "in the comatorium" })
       @serialized_role = Chef::JSONCompat.to_json(@role)
     end
 
@@ -189,20 +189,20 @@ describe Chef::Role do
     end
 
     it "should include 'run_list'" do
-      #Activesupport messes with Chef json formatting
-      #This test should pass with and without activesupport
+      # Activesupport messes with Chef json formatting
+      # This test should pass with and without activesupport
       expect(@serialized_role).to match(/"run_list":\["recipe\[one\]","recipe\[two\]","role\[a\]"\]/)
     end
 
     describe "and it has per-environment run lists" do
       before do
         @role.env_run_lists("_default" => ["one", "two", "role[a]"], "production" => ["role[monitoring]", "role[auditing]", "role[apache]"], "dev" => ["role[nginx]"])
-        @serialized_role = Chef::JSONCompat.parse(Chef::JSONCompat.to_json(@role), :create_additions => false)
+        @serialized_role = Chef::JSONCompat.parse(Chef::JSONCompat.to_json(@role), create_additions: false)
       end
 
       it "includes the per-environment run lists" do
-        #Activesupport messes with Chef json formatting
-        #This test should pass with and without activesupport
+        # Activesupport messes with Chef json formatting
+        # This test should pass with and without activesupport
         expect(@serialized_role["env_run_lists"]["production"]).to eq(["role[monitoring]", "role[auditing]", "role[apache]"])
         expect(@serialized_role["env_run_lists"]["dev"]).to eq(["role[nginx]"])
       end
@@ -218,7 +218,7 @@ describe Chef::Role do
     end
   end
 
-  describe "when created from JSON", :json => true do
+  describe "when created from JSON", json: true do
     before(:each) do
       @role.name("mars_volta")
       @role.description("Great band!")
@@ -245,9 +245,9 @@ describe Chef::Role do
     end
   end
 
-  ROLE_DSL = <<-EOR
-name "ceiling_cat"
-description "like Aliens, but furry"
+  ROLE_DSL = <<~EOR.freeze
+    name "ceiling_cat"
+    description "like Aliens, but furry"
 EOR
 
   describe "when loading from disk" do

data/spec/unit/run_context_spec.rb

@@ -184,7 +184,7 @@ describe Chef::RunContext do
 
   describe "handling reboot requests" do
     let(:expected) do
-      { :reason => "spec tests require a reboot" }
+      { reason: "spec tests require a reboot" }
     end
 
     it "stores and deletes the reboot request" do

data/spec/unit/run_list/run_list_item_spec.rb

@@ -22,15 +22,15 @@ 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")
+      item = Chef::RunList::RunListItem.new(type: "fuuu", name: "uuuu")
       expect(item.to_s).to eq("fuuu[uuuu]")
     end
 

data/spec/unit/run_list/versioned_recipe_list_spec.rb

@@ -54,25 +54,25 @@ describe Chef::RunList::VersionedRecipeList do
     it "should allow you to specify a version" do
       list.add_recipe "rails", "1.0.0"
       expect(list).to eq(%w{apt god apache2 rails})
-      expect(list.with_versions).to include({ :name => "rails", :version => "1.0.0" })
+      expect(list.with_versions).to include({ name: "rails", version: "1.0.0" })
     end
 
     it "should allow you to specify a version for a recipe that already exists" do
       list.add_recipe "apt", "1.2.3"
       expect(list).to eq(%w{apt god apache2})
-      expect(list.with_versions).to include({ :name => "apt", :version => "1.2.3" })
+      expect(list.with_versions).to include({ name: "apt", version: "1.2.3" })
     end
 
     it "should allow you to specify the same version of a recipe twice" do
       list.add_recipe "rails", "1.0.0"
       list.add_recipe "rails", "1.0.0"
-      expect(list.with_versions).to include({ :name => "rails", :version => "1.0.0" })
+      expect(list.with_versions).to include({ name: "rails", version: "1.0.0" })
     end
 
     it "should allow you to spcify no version, even when a version already exists" do
       list.add_recipe "rails", "1.0.0"
       list.add_recipe "rails"
-      expect(list.with_versions).to include({ :name => "rails", :version => "1.0.0" })
+      expect(list.with_versions).to include({ name: "rails", version: "1.0.0" })
     end
 
     it "should not allow multiple versions of the same recipe" do
@@ -85,9 +85,9 @@ describe Chef::RunList::VersionedRecipeList do
 
     let(:versioned_recipes) do
       [
-        { :name => "apt", :version => "1.0.0" },
-        { :name => "god", :version => nil },
-        { :name => "apache2", :version => "0.0.1" },
+        { name: "apt", version: "1.0.0" },
+        { name: "god", version: nil },
+        { name: "apache2", version: "0.0.1" },
       ]
     end
     it "should return an array of hashes with :name and :version" do
@@ -106,9 +106,9 @@ describe Chef::RunList::VersionedRecipeList do
 
     let(:versioned_recipes) do
       [
-        { :name => "apt", :version => "~> 1.2.0" },
-        { :name => "god", :version => nil },
-        { :name => "apache2", :version => "0.0.1" },
+        { name: "apt", version: "~> 1.2.0" },
+        { name: "god", version: nil },
+        { name: "apache2", version: "0.0.1" },
       ]
     end
 
@@ -151,7 +151,7 @@ describe Chef::RunList::VersionedRecipeList do
 
       let(:versioned_recipes) do
         [
-          { :name => "apt", :version => "~> 1.2.0" },
+          { name: "apt", version: "~> 1.2.0" },
         ]
       end
 
@@ -170,7 +170,7 @@ describe Chef::RunList::VersionedRecipeList do
 
       let(:versioned_recipes) do
         [
-          { :name => "apt::cacher", :version => "~> 1.2.0" },
+          { name: "apt::cacher", version: "~> 1.2.0" },
         ]
       end
 

data/spec/unit/run_list_spec.rb

@@ -170,12 +170,12 @@ describe Chef::RunList do
       @role = Chef::Role.new
       @role.name "stubby"
       @role.run_list "one", "two"
-      @role.default_attributes :one => :two
-      @role.override_attributes :three => :four
+      @role.default_attributes one: :two
+      @role.override_attributes three: :four
       @role.env_run_list["production"] = Chef::RunList.new( "one", "two", "five")
 
       allow(Chef::Role).to receive(:load).and_return(@role)
-      @rest = double("Chef::ServerAPI", { :get => @role.to_hash, :url => "/" })
+      @rest = double("Chef::ServerAPI", { get: @role.to_hash, url: "/" })
       allow(Chef::ServerAPI).to receive(:new).and_return(@rest)
 
       @run_list << "role[stubby]"
@@ -197,7 +197,7 @@ describe Chef::RunList do
 
     describe "from the chef server" do
       it "should load the role from the chef server" do
-        #@rest.should_receive(:get).with("roles/stubby")
+        # @rest.should_receive(:get).with("roles/stubby")
         expansion = @run_list.expand("_default", "server")
         expect(expansion.recipes).to eq(%w{one two kitty})
       end
@@ -263,7 +263,7 @@ describe Chef::RunList do
     it "should recurse into a child role" do
       dog = Chef::Role.new
       dog.name "dog"
-      dog.default_attributes :seven => :nine
+      dog.default_attributes seven: :nine
       dog.run_list "three"
       @role.run_list << "role[dog]"
       allow(Chef::Role).to receive(:from_disk).with("stubby").and_return(@role)
@@ -277,7 +277,7 @@ describe Chef::RunList do
     it "should not recurse infinitely" do
       dog = Chef::Role.new
       dog.name "dog"
-      dog.default_attributes :seven => :nine
+      dog.default_attributes seven: :nine
       dog.run_list "role[dog]", "three"
       @role.run_list << "role[dog]"
       allow(Chef::Role).to receive(:from_disk).with("stubby").and_return(@role)

data/spec/unit/runner_spec.rb

@@ -258,10 +258,10 @@ describe Chef::Runner do
       end
       expect(exception).to be_a(Chef::Exceptions::MultipleFailures)
 
-      expected_message = <<-E
-Multiple failures occurred:
-* FailureProvider::ChefClientFail occurred in delayed notification: [explode] (dynamically defined) had an error: FailureProvider::ChefClientFail: chef had an error of some sort
-* FailureProvider::ChefClientFail occurred in delayed notification: [explode again] (dynamically defined) had an error: FailureProvider::ChefClientFail: chef had an error of some sort
+      expected_message = <<~E
+        Multiple failures occurred:
+        * FailureProvider::ChefClientFail occurred in delayed notification: [explode] (dynamically defined) had an error: FailureProvider::ChefClientFail: chef had an error of some sort
+        * FailureProvider::ChefClientFail occurred in delayed notification: [explode again] (dynamically defined) had an error: FailureProvider::ChefClientFail: chef had an error of some sort
       E
       expect(exception.message).to eq(expected_message)
 

data/spec/unit/scan_access_control_spec.rb

@@ -49,7 +49,7 @@ describe Chef::ScanAccessControl do
   describe "when the fs entity exists" do
 
     before do
-      @stat = double("File::Stat for #{@new_resource.path}", :uid => 0, :gid => 0, :mode => 00100644)
+      @stat = double("File::Stat for #{@new_resource.path}", uid: 0, gid: 0, mode: 00100644)
       expect(File).to receive(:realpath).with(@new_resource.path).and_return(@real_file)
       expect(File).to receive(:stat).with(@real_file).and_return(@stat)
       expect(File).to receive(:exist?).with(@new_resource.path).and_return(true)
@@ -128,7 +128,7 @@ describe Chef::ScanAccessControl do
       end
 
       it "sets the owner of current_resource to the username of the current owner" do
-        @root_passwd = double("Struct::Passwd for uid 0", :name => "root")
+        @root_passwd = double("Struct::Passwd for uid 0", name: "root")
         expect(Etc).to receive(:getpwuid).with(0).and_return(@root_passwd)
         @scanner.set_all!
 
@@ -163,7 +163,7 @@ describe Chef::ScanAccessControl do
       end
 
       it "sets the group of the current resource to the group name" do
-        @group_entry = double("Struct::Group for wheel", :name => "wheel")
+        @group_entry = double("Struct::Group for wheel", name: "wheel")
         expect(Etc).to receive(:getgrgid).with(0).and_return(@group_entry)
         @scanner.set_all!
 

data/spec/unit/shell/model_wrapper_spec.rb

@@ -21,13 +21,13 @@ require "ostruct"
 
 describe Shell::ModelWrapper do
   before do
-    @model = OpenStruct.new(:name => "Chef::Node")
+    @model = OpenStruct.new(name: "Chef::Node")
     @wrapper = Shell::ModelWrapper.new(@model)
   end
 
   describe "when created with an explicit model_symbol" do
     before do
-      @model = OpenStruct.new(:name => "Chef::ApiClient")
+      @model = OpenStruct.new(name: "Chef::ApiClient")
       @wrapper = Shell::ModelWrapper.new(@model, :client)
     end
 
@@ -46,7 +46,7 @@ describe Shell::ModelWrapper do
       @node_1.name("sammich")
       @node_2 = Chef::Node.new
       @node_2.name("yummy")
-      @server_response = { :node_1 => @node_1, :node_2 => @node_2 }
+      @server_response = { node_1: @node_1, node_2: @node_2 }
       @wrapper = Shell::ModelWrapper.new(Chef::Node)
       allow(Chef::Node).to receive(:list).and_return(@server_response)
     end
@@ -67,7 +67,7 @@ describe Shell::ModelWrapper do
       @node_1.name("sammich")
       @node_2 = Chef::Node.new
       @node_2.name("yummy")
-      @server_response = { :node_1 => @node_1, :node_2 => @node_2 }
+      @server_response = { node_1: @node_1, node_2: @node_2 }
       @wrapper = Shell::ModelWrapper.new(Chef::Node)
 
       # Creating a Chef::Search::Query object tries to read the private key...

data/spec/unit/shell/shell_ext_spec.rb

@@ -34,8 +34,8 @@ describe Shell::Extensions do
     it "finds a subsession in irb for an object" do
       target_context_obj = Chef::Node.new
 
-      irb_context = double("context", :main => target_context_obj)
-      irb_session = double("irb session", :context => irb_context)
+      irb_context = double("context", main: target_context_obj)
+      irb_session = double("irb session", context: irb_context)
       @job_manager.jobs = [[:thread, irb_session]]
       allow(@root_context).to receive(:jobs).and_return(@job_manager)
       @root_context.ensure_session_select_defined
@@ -92,9 +92,9 @@ describe Shell::Extensions do
     end
 
     it "prints node attributes" do
-      node = double("node", :attribute => { :foo => :bar })
+      node = double("node", attribute: { foo: :bar })
       @shell_client.node = node
-      expect(@root_context).to receive(:pp).with({ :foo => :bar })
+      expect(@root_context).to receive(:pp).with({ foo: :bar })
       @root_context.ohai
       expect(@root_context).to receive(:pp).with(:bar)
       @root_context.ohai(:foo)

data/spec/unit/shell/shell_session_spec.rb

@@ -53,16 +53,16 @@ describe Shell::ClientSession do
   let(:session) { Shell::ClientSession.instance }
   let(:client) do
     double("Chef::Client.new",
-      :run_ohai => true,
-      :load_node => true,
-      :build_node => true,
-      :register => true,
-      :sync_cookbooks => {}
+      run_ohai: true,
+      load_node: true,
+      build_node: true,
+      register: true,
+      sync_cookbooks: {}
     )
   end
 
   before do
-    Chef::Config[:shell_config] = { :override_runlist => [Chef::RunList::RunListItem.new("shell::override")] }
+    Chef::Config[:shell_config] = { override_runlist: [Chef::RunList::RunListItem.new("shell::override")] }
     session.node = node
     session.json_configuration = json_attribs
   end
@@ -90,16 +90,16 @@ describe Shell::SoloSession do
   let(:session) { Shell::SoloSession.instance }
   let(:client) do
     double("Chef::Client.new",
-      :run_ohai => true,
-      :load_node => true,
-      :build_node => true,
-      :register => true,
-      :sync_cookbooks => {}
+      run_ohai: true,
+      load_node: true,
+      build_node: true,
+      register: true,
+      sync_cookbooks: {}
     )
   end
 
   before do
-    Chef::Config[:shell_config] = { :override_runlist => [Chef::RunList::RunListItem.new("shell::override")] }
+    Chef::Config[:shell_config] = { override_runlist: [Chef::RunList::RunListItem.new("shell::override")] }
     session.node = node
     session.json_configuration = json_attribs
   end
@@ -128,18 +128,18 @@ describe Shell::StandAloneSession do
   let(:session) { Shell::StandAloneSession.instance }
   let(:client) do
     double("Chef::Client.new",
-      :run_ohai => true,
-      :load_node => true,
-      :build_node => true,
-      :register => true,
-      :sync_cookbooks => {}
+      run_ohai: true,
+      load_node: true,
+      build_node: true,
+      register: true,
+      sync_cookbooks: {}
     )
   end
   let(:recipe) { Chef::Recipe.new(nil, nil, run_context) }
   let(:run_context) { Chef::RunContext.new(node, {}, events) }
 
   before do
-    Chef::Config[:shell_config] = { :override_runlist => [Chef::RunList::RunListItem.new("shell::override")] }
+    Chef::Config[:shell_config] = { override_runlist: [Chef::RunList::RunListItem.new("shell::override")] }
     session.node = node
     session.json_configuration = json_attribs
     session.run_context = run_context
@@ -166,7 +166,7 @@ describe Shell::StandAloneSession do
   it "runs chef with the standalone recipe" do
     allow(session).to receive(:node_built?).and_return(true)
     allow(Chef::Log).to receive(:level)
-    chef_runner = double("Chef::Runner.new", :converge => :converged)
+    chef_runner = double("Chef::Runner.new", converge: :converged)
     # pre-heat resource collection cache
     session.resource_collection
 
@@ -185,7 +185,7 @@ describe Shell::SoloLegacySession do
   let(:json_attribs) { { "a" => "b" } }
 
   before do
-    Chef::Config[:shell_config] = { :override_runlist => [Chef::RunList::RunListItem.new("shell::override")] }
+    Chef::Config[:shell_config] = { override_runlist: [Chef::RunList::RunListItem.new("shell::override")] }
     Chef::Config[:shell_solo] = true
     @session = Shell::SoloLegacySession.instance
     @node = Chef::Node.new
@@ -214,7 +214,7 @@ describe Shell::SoloLegacySession do
   it "keeps json attribs and passes them to the node for consumption" do
     @session.node_attributes = { "besnard_lakes" => "are_the_dark_horse" }
     expect(@session.node["besnard_lakes"]).to eq("are_the_dark_horse")
-    #pending "1) keep attribs in an ivar 2) pass them to the node 3) feed them to the node on reset"
+    # pending "1) keep attribs in an ivar 2) pass them to the node 3) feed them to the node on reset"
   end
 
   it "generates its resource collection from the compiled cookbooks and the ad hoc recipe" do
@@ -223,13 +223,13 @@ describe Shell::SoloLegacySession do
     @run_context.resource_collection << kitteh_cat
     keyboard_cat = Chef::Resource::Cat.new("keyboard_cat")
     @recipe.run_context.resource_collection << keyboard_cat
-    #@session.rebuild_collection
+    # @session.rebuild_collection
     expect(@session.resource_collection).to include(kitteh_cat, keyboard_cat)
   end
 
   it "runs chef with a resource collection from the compiled cookbooks" do
     allow(@session).to receive(:node_built?).and_return(true)
-    chef_runner = double("Chef::Runner.new", :converge => :converged)
+    chef_runner = double("Chef::Runner.new", converge: :converged)
     expect(Chef::Runner).to receive(:new).with(an_instance_of(Chef::RunContext)).and_return(chef_runner)
 
     expect(@recipe.run_chef).to eq(:converged)
@@ -237,11 +237,11 @@ describe Shell::SoloLegacySession do
 
   it "passes the shell CLI args to the client" do
     @client = double("Chef::Client.new",
-                     :run_ohai => true,
-                     :load_node => true,
-                     :build_node => true,
-                     :register => true,
-                     :sync_cookbooks => {})
+                     run_ohai: true,
+                     load_node: true,
+                     build_node: true,
+                     register: true,
+                     sync_cookbooks: {})
     expect(Chef::Client).to receive(:new).with(json_attribs, Chef::Config[:shell_config]).and_return(@client)
     @session.json_configuration = json_attribs
     @session.send(:rebuild_node)