chef 12.13.37 → 12.14.60

data/spec/unit/chef_class_spec.rb

@@ -85,7 +85,7 @@ describe "Chef class" do
     end
   end
 
-  context '#event_handler' do
+  context "#event_handler" do
     it "adds a new handler" do
       x = 1
       Chef.event_handler do

data/spec/unit/chef_fs/data_handler/group_handler_spec.rb

@@ -29,7 +29,7 @@ class TestEntry < Mash
 end
 
 describe Chef::ChefFS::DataHandler::GroupDataHandler do
-  describe '#normalize_for_post' do
+  describe "#normalize_for_post" do
     let(:entry) do
       TestEntry.new("workers.json", "hive")
     end

data/spec/unit/chef_fs/diff_spec.rb

@@ -32,7 +32,7 @@ describe "diff", :uses_diff => true do
   include FileSystemSupport
 
   context "with two filesystems with all types of difference" do
-    let(:a) {
+    let(:a) do
       memory_fs("a", {
         :both_dirs => {
           :sub_both_dirs => { :subsub => nil },
@@ -58,8 +58,8 @@ describe "diff", :uses_diff => true do
         :dir_in_a_file_in_b => {},
         :file_in_a_dir_in_b => nil,
       }, /cannot_be_in_a/)
-    }
-    let(:b) {
+    end
+    let(:b) do
       memory_fs("b", {
         :both_dirs => {
           :sub_both_dirs => { :subsub => nil },
@@ -85,7 +85,7 @@ describe "diff", :uses_diff => true do
         :dir_in_a_file_in_b => nil,
         :file_in_a_dir_in_b => {},
       }, /cannot_be_in_b/)
-    }
+    end
     it "Chef::ChefFS::CommandLine.diff_print(/)" do
       results = []
       Chef::ChefFS::CommandLine.diff_print(pattern("/"), a, b, nil, nil) do |diff|

data/spec/unit/chef_fs/file_system/operation_failed_error_spec.rb

@@ -30,17 +30,17 @@ describe Chef::ChefFS::FileSystem::OperationFailedError do
         allow(@response).to receive(:code).and_return("400")
         allow(@response).to receive(:body).and_return(response_body)
         exception = Net::HTTPServerException.new("(exception) unauthorized", @response)
-        expect {
+        expect do
           raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self, exception), error_message
-        }.to raise_error(Chef::ChefFS::FileSystem::OperationFailedError, "#{error_message} cause: #{response_body}")
+        end.to raise_error(Chef::ChefFS::FileSystem::OperationFailedError, "#{error_message} cause: #{response_body}")
       end
     end
 
     context "does not have a cause attribute" do
       it "does not include error cause" do
-        expect {
+        expect do
           raise Chef::ChefFS::FileSystem::OperationFailedError.new(:write, self), error_message
-        }.to raise_error(Chef::ChefFS::FileSystem::OperationFailedError, error_message)
+        end.to raise_error(Chef::ChefFS::FileSystem::OperationFailedError, error_message)
       end
     end
   end

data/spec/unit/chef_fs/file_system_spec.rb

@@ -55,7 +55,7 @@ describe Chef::ChefFS::FileSystem do
   end
 
   context "with a populated filesystem" do
-    let(:fs) {
+    let(:fs) do
       memory_fs("", {
         :a => {
           :aa => {
@@ -69,7 +69,7 @@ describe Chef::ChefFS::FileSystem do
         :x => "",
         :y => {},
       })
-    }
+    end
     context "list" do
       it "/**" do
         list_should_yield_paths(fs, "/**", "/", "/a", "/x", "/y", "/a/aa", "/a/aa/c", "/a/aa/zz", "/a/ab", "/a/ab/c")

data/spec/unit/chef_fs/parallelizer.rb

@@ -35,9 +35,9 @@ describe Chef::ChefFS::Parallelizer do
 
     context "With :ordered => false (unordered output)" do
       it "An empty input produces an empty output" do
-        parallelize([], :ordered => false) do
+        expect(parallelize([], :ordered => false) do
           sleep 10
-        end.to_a == []
+        end.to_a).to eql([])
         expect(elapsed_time).to be < 0.1
       end
 
@@ -107,9 +107,9 @@ describe Chef::ChefFS::Parallelizer do
 
     context "With :ordered => true (ordered output)" do
       it "An empty input produces an empty output" do
-        parallelize([]) do
+        expect(parallelize([]) do
           sleep 10
-        end.to_a == []
+        end.to_a).to eql([])
         expect(elapsed_time).to be < 0.1
       end
 
@@ -211,9 +211,7 @@ describe Chef::ChefFS::Parallelizer do
             occupying_job_finished[0] = true
           end.wait
         end
-        until started
-          sleep(0.01)
-        end
+        sleep(0.01) until started
       end
 
       after :each do

data/spec/unit/cookbook/metadata_spec.rb

@@ -461,21 +461,21 @@ describe Chef::Cookbook::Metadata do
       expect(metadata.grouping("/db/mysql/databases/tuning", group)).to eq(group)
     end
     it "should not accept anything but a string for display_name" do
-      expect {
+      expect do
         metadata.grouping("db/mysql/databases", :title => "foo")
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.grouping("db/mysql/databases", :title => Hash.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should not accept anything but a string for the description" do
-      expect {
+      expect do
         metadata.grouping("db/mysql/databases", :description => "foo")
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.grouping("db/mysql/databases", :description => Hash.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end
 
@@ -498,63 +498,63 @@ describe Chef::Cookbook::Metadata do
     end
 
     it "should not accept anything but a string for display_name" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :display_name => "foo")
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :display_name => Hash.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should not accept anything but a string for the description" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :description => "foo")
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :description => Hash.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should not accept anything but a string for the source_url" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :source_url => "foo")
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :source_url => Hash.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should not accept anything but a string for the issues_url" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :issues_url => "foo")
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :issues_url => Hash.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should not accept anything but true or false for the privacy flag" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :privacy => true)
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :privacy => false)
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :privacy => "true")
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should not accept anything but an array of strings for choice" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :choice => %w{dedicated shared})
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :choice => [10, "shared"])
-      }.to raise_error(ArgumentError)
-      expect {
+      end.to raise_error(ArgumentError)
+      expect do
         metadata.attribute("db/mysql/databases", :choice => Hash.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should set choice to empty array by default" do
@@ -563,15 +563,15 @@ describe Chef::Cookbook::Metadata do
     end
 
     it "should let calculated be true or false" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :calculated => true)
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :calculated => false)
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :calculated => Hash.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should set calculated to false by default" do
@@ -580,55 +580,55 @@ describe Chef::Cookbook::Metadata do
     end
 
     it "accepts String for the attribute type" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :type => "string")
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it "accepts Array for the attribute type" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :type => "array")
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :type => Array.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "accepts symbol for the attribute type" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :type => "symbol")
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it "should let type be hash (backwards compatibility only)" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :type => "hash")
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it "should let required be required, recommended or optional" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :required => "required")
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :required => "recommended")
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :required => "optional")
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it "should convert required true to required" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :required => true)
-      }.not_to raise_error
+      end.not_to raise_error
       #attrib = metadata.attributes["db/mysql/databases"][:required].should == "required"
     end
 
     it "should convert required false to optional" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :required => false)
-      }.not_to raise_error
+      end.not_to raise_error
       #attrib = metadata.attributes["db/mysql/databases"][:required].should == "optional"
     end
 
@@ -638,12 +638,12 @@ describe Chef::Cookbook::Metadata do
     end
 
     it "should make sure recipes is an array" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :recipes => [])
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :required => Hash.new)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should set recipes to an empty array by default" do
@@ -652,24 +652,24 @@ describe Chef::Cookbook::Metadata do
     end
 
     it "should allow the default value to be a string, array, hash, boolean or numeric" do
-      expect {
+      expect do
         metadata.attribute("db/mysql/databases", :default => [])
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :default => {})
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :default => "alice in chains")
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :default => 1337)
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :default => true)
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         metadata.attribute("db/mysql/databases", :required => :not_gonna_do_it)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should limit the types allowed in the choice array" do
@@ -678,87 +678,87 @@ describe Chef::Cookbook::Metadata do
         :choice => %w{test1 test2},
         :default => "test1",
       }
-      expect {
+      expect do
         metadata.attribute("test_cookbook/test", options)
-      }.not_to raise_error
+      end.not_to raise_error
 
       options = {
         :type => "boolean",
         :choice => [ true, false ],
         :default => true,
       }
-      expect {
+      expect do
         metadata.attribute("test_cookbook/test", options)
-      }.not_to raise_error
+      end.not_to raise_error
 
       options = {
         :type => "numeric",
         :choice => [ 1337, 420 ],
         :default => 1337,
       }
-      expect {
+      expect do
         metadata.attribute("test_cookbook/test", options)
-      }.not_to raise_error
+      end.not_to raise_error
 
       options = {
         :type => "numeric",
         :choice => [ true, "false" ],
         :default => false,
       }
-      expect {
+      expect do
         metadata.attribute("test_cookbook/test", options)
-      }.to raise_error(Chef::Exceptions::ValidationFailed)
+      end.to raise_error(Chef::Exceptions::ValidationFailed)
     end
 
     it "should error if default used with calculated" do
-      expect {
+      expect do
         attrs = {
           :calculated => true,
           :default => [ "I thought you said calculated" ],
         }
         metadata.attribute("db/mysql/databases", attrs)
-      }.to raise_error(ArgumentError)
-      expect {
+      end.to raise_error(ArgumentError)
+      expect do
         attrs = {
           :calculated => true,
           :default => "I thought you said calculated",
         }
         metadata.attribute("db/mysql/databases", attrs)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
 
     it "should allow a default that is a choice" do
-      expect {
+      expect do
         attrs = {
           :choice => %w{a b c},
           :default => "b",
         }
         metadata.attribute("db/mysql/databases", attrs)
-      }.not_to raise_error
-      expect {
+      end.not_to raise_error
+      expect do
         attrs = {
           :choice => %w{a b c d e},
           :default => %w{b d},
         }
         metadata.attribute("db/mysql/databases", attrs)
-      }.not_to raise_error
+      end.not_to raise_error
     end
 
     it "should error if default is not a choice" do
-      expect {
+      expect do
         attrs = {
           :choice => %w{a b c},
           :default => "d",
         }
         metadata.attribute("db/mysql/databases", attrs)
-      }.to raise_error(ArgumentError)
-      expect {
+      end.to raise_error(ArgumentError)
+      expect do
         attrs = {
           :choice => %w{a b c d e},
           :default => %w{b z},
         }
         metadata.attribute("db/mysql/databases", attrs)
-      }.to raise_error(ArgumentError)
+      end.to raise_error(ArgumentError)
     end
   end