chef 12.0.3-x86-mingw32 → 12.1.0.rc.0-x86-mingw32

data/spec/unit/knife/user_show_spec.rb

@@ -27,15 +27,15 @@ describe Chef::Knife::UserShow do
   end
 
   it 'loads and displays the user' do
-    Chef::User.should_receive(:load).with('my_user').and_return(@user_mock)
-    @knife.should_receive(:format_for_display).with(@user_mock)
+    expect(Chef::User).to receive(:load).with('my_user').and_return(@user_mock)
+    expect(@knife).to receive(:format_for_display).with(@user_mock)
     @knife.run
   end
 
   it 'prints usage and exits when a user name is not provided' do
     @knife.name_args = []
-    @knife.should_receive(:show_usage)
-    @knife.ui.should_receive(:fatal)
-    lambda { @knife.run }.should raise_error(SystemExit)
+    expect(@knife).to receive(:show_usage)
+    expect(@knife.ui).to receive(:fatal)
+    expect { @knife.run }.to raise_error(SystemExit)
   end
 end

data/spec/unit/knife_spec.rb

@@ -42,7 +42,7 @@ describe Chef::Knife do
     allow(Chef::Log).to receive(:init)
     allow(Chef::Log).to receive(:level)
     [:debug, :info, :warn, :error, :crit].each do |level_sym|
-      Chef::Log.stub(level_sym)
+      allow(Chef::Log).to receive(level_sym)
     end
     allow(Chef::Knife).to receive(:puts)
   end
@@ -68,27 +68,27 @@ describe Chef::Knife do
     end
 
     it "has a category based on its name" do
-      KnifeSpecs::TestNameMapping.subcommand_category.should == 'test'
+      expect(KnifeSpecs::TestNameMapping.subcommand_category).to eq('test')
     end
 
-    it "has an explictly defined category if set" do
-      KnifeSpecs::TestExplicitCategory.subcommand_category.should == 'cookbook site'
+    it "has an explicitly defined category if set" do
+      expect(KnifeSpecs::TestExplicitCategory.subcommand_category).to eq('cookbook site')
     end
 
     it "can reference the subcommand by its snake cased name" do
-      Chef::Knife.subcommands['test_name_mapping'].should equal(KnifeSpecs::TestNameMapping)
+      expect(Chef::Knife.subcommands['test_name_mapping']).to equal(KnifeSpecs::TestNameMapping)
     end
 
     it "lists subcommands by category" do
-      Chef::Knife.subcommands_by_category['test'].should include('test_name_mapping')
+      expect(Chef::Knife.subcommands_by_category['test']).to include('test_name_mapping')
     end
 
     it "lists subcommands by category when the subcommands have explicit categories" do
-      Chef::Knife.subcommands_by_category['cookbook site'].should include('test_explicit_category')
+      expect(Chef::Knife.subcommands_by_category['cookbook site']).to include('test_explicit_category')
     end
 
     it "has empty dependency_loader list by default" do
-      KnifeSpecs::TestNameMapping.dependency_loaders.should be_empty
+      expect(KnifeSpecs::TestNameMapping.dependency_loaders).to be_empty
     end
   end
 
@@ -104,22 +104,22 @@ describe Chef::Knife do
 
       Chef::Knife.load_commands
 
-      Chef::Knife.subcommands.should have_key("super_awesome_command")
-      Chef::Knife.subcommands["super_awesome_command"].should == SuperAwesomeCommand
+      expect(Chef::Knife.subcommands).to have_key("super_awesome_command")
+      expect(Chef::Knife.subcommands["super_awesome_command"]).to eq(SuperAwesomeCommand)
     end
 
     it "guesses a category from a given ARGV" do
       Chef::Knife.subcommands_by_category["cookbook"] << :cookbook
       Chef::Knife.subcommands_by_category["cookbook site"] << :cookbook_site
-      Chef::Knife.guess_category(%w{cookbook foo bar baz}).should == 'cookbook'
-      Chef::Knife.guess_category(%w{cookbook site foo bar baz}).should == 'cookbook site'
-      Chef::Knife.guess_category(%w{cookbook site --help}).should == 'cookbook site'
+      expect(Chef::Knife.guess_category(%w{cookbook foo bar baz})).to eq('cookbook')
+      expect(Chef::Knife.guess_category(%w{cookbook site foo bar baz})).to eq('cookbook site')
+      expect(Chef::Knife.guess_category(%w{cookbook site --help})).to eq('cookbook site')
     end
 
     it "finds a subcommand class based on ARGV" do
       Chef::Knife.subcommands["cookbook_site_vendor"] = :CookbookSiteVendor
       Chef::Knife.subcommands["cookbook"] = :Cookbook
-      Chef::Knife.subcommand_class_from(%w{cookbook site vendor --help foo bar baz}).should == :CookbookSiteVendor
+      expect(Chef::Knife.subcommand_class_from(%w{cookbook site vendor --help foo bar baz})).to eq(:CookbookSiteVendor)
     end
 
   end
@@ -137,9 +137,9 @@ describe Chef::Knife do
     let(:request_mock) { {} }
 
     let(:rest) do
-      Net::HTTP.stub(:new).and_return(http_client)
-      Chef::RequestID.instance.stub(:request_id).and_return(request_id)
-      Chef::Config.stub(:chef_server_url).and_return("https://api.opscode.piab")
+      allow(Net::HTTP).to receive(:new).and_return(http_client)
+      allow(Chef::RequestID.instance).to receive(:request_id).and_return(request_id)
+      allow(Chef::Config).to receive(:chef_server_url).and_return("https://api.opscode.piab")
       command = Chef::Knife.run(%w{test yourself})
       rest = command.noauth_rest
       rest
@@ -147,7 +147,7 @@ describe Chef::Knife do
 
     let!(:http_client) do
       http_client = Net::HTTP.new(url.host, url.port)
-      http_client.stub(:request).and_yield(http_response).and_return(http_response)
+      allow(http_client).to receive(:request).and_yield(http_response).and_return(http_response)
       http_client
     end
 
@@ -155,8 +155,8 @@ describe Chef::Knife do
 
     let(:http_response) do
       http_response = Net::HTTPSuccess.new("1.1", "200", "successful rest req")
-      http_response.stub(:read_body)
-      http_response.stub(:body).and_return(body)
+      allow(http_response).to receive(:read_body)
+      allow(http_response).to receive(:body).and_return(body)
       http_response["Content-Length"] = body.bytesize.to_s
       http_response
     end
@@ -173,7 +173,7 @@ describe Chef::Knife do
     end
 
     it "confirms that the headers include X-Remote-Request-Id" do
-      Net::HTTP::Get.should_receive(:new).with("/monkey", headers).and_return(request_mock)
+      expect(Net::HTTP::Get).to receive(:new).with("/monkey", headers).and_return(request_mock)
       rest.get_rest("monkey")
     end
   end
@@ -197,26 +197,26 @@ describe Chef::Knife do
       # there is special hackery to return the subcommand instance going on here.
       command = Chef::Knife.run(%w{test yourself}, extra_opts)
       editor_opts = command.options[:editor]
-      editor_opts[:long].should         == "--editor EDITOR"
-      editor_opts[:description].should  == "Set the editor to use for interactive commands"
-      editor_opts[:short].should        == "-e EDITOR"
-      editor_opts[:default].should      == "/usr/bin/vim"
+      expect(editor_opts[:long]).to         eq("--editor EDITOR")
+      expect(editor_opts[:description]).to  eq("Set the editor to use for interactive commands")
+      expect(editor_opts[:short]).to        eq("-e EDITOR")
+      expect(editor_opts[:default]).to      eq("/usr/bin/vim")
     end
 
     it "creates an instance of the subcommand and runs it" do
       command = Chef::Knife.run(%w{test yourself})
-      command.should be_an_instance_of(KnifeSpecs::TestYourself)
-      command.ran.should be_true
+      expect(command).to be_an_instance_of(KnifeSpecs::TestYourself)
+      expect(command.ran).to be_truthy
     end
 
     it "passes the command specific args to the subcommand" do
       command = Chef::Knife.run(%w{test yourself with some args})
-      command.name_args.should == %w{with some args}
+      expect(command.name_args).to eq(%w{with some args})
     end
 
     it "excludes the command name from the name args when parts are joined with underscores" do
       command = Chef::Knife.run(%w{test_yourself with some args})
-      command.name_args.should == %w{with some args}
+      expect(command.name_args).to eq(%w{with some args})
     end
 
     it "exits if no subcommand matches the CLI args" do
@@ -230,7 +230,7 @@ describe Chef::Knife do
 
     it "loads lazy dependencies" do
       Chef::Knife.run(%w{test yourself})
-      KnifeSpecs::TestYourself.test_deps_loaded.should be_true
+      expect(KnifeSpecs::TestYourself.test_deps_loaded).to be_truthy
     end
 
     it "loads lazy dependencies from multiple deps calls" do
@@ -240,8 +240,8 @@ describe Chef::Knife do
       end
 
       Chef::Knife.run(%w{test yourself})
-      KnifeSpecs::TestYourself.test_deps_loaded.should be_true
-      other_deps_loaded.should be_true
+      expect(KnifeSpecs::TestYourself.test_deps_loaded).to be_truthy
+      expect(other_deps_loaded).to be_truthy
     end
 
     describe "merging configuration options" do
@@ -254,21 +254,21 @@ describe Chef::Knife do
       it "prefers the default value if no config or command line value is present" do
         knife_command = KnifeSpecs::TestYourself.new([]) #empty argv
         knife_command.configure_chef
-        knife_command.config[:opt_with_default].should == "default-value"
+        expect(knife_command.config[:opt_with_default]).to eq("default-value")
       end
 
       it "prefers a value in Chef::Config[:knife] to the default" do
         Chef::Config[:knife][:opt_with_default] = "from-knife-config"
         knife_command = KnifeSpecs::TestYourself.new([]) #empty argv
         knife_command.configure_chef
-        knife_command.config[:opt_with_default].should == "from-knife-config"
+        expect(knife_command.config[:opt_with_default]).to eq("from-knife-config")
       end
 
       it "prefers a value from command line over Chef::Config and the default" do
         Chef::Config[:knife][:opt_with_default] = "from-knife-config"
         knife_command = KnifeSpecs::TestYourself.new(["-D", "from-cli"])
         knife_command.configure_chef
-        knife_command.config[:opt_with_default].should == "from-cli"
+        expect(knife_command.config[:opt_with_default]).to eq("from-cli")
       end
 
       context "verbosity is greater than zero" do
@@ -311,7 +311,7 @@ describe Chef::Knife do
     end
 
     it "does not have lazy dependencies loaded" do
-      expect(knife.class.test_deps_loaded).to be(nil)
+      expect(knife.class.test_deps_loaded).not_to be_truthy
     end
   end
 

data/spec/unit/lwrp_spec.rb

@@ -33,17 +33,41 @@ describe "LWRP" do
 
   describe "when overriding an existing class" do
     before :each do
-      $stderr.stub(:write)
+      allow($stderr).to receive(:write)
     end
 
+    it "should not skip loading a resource when there's a top level symbol of the same name" do
+      Object.const_set('LwrpFoo', Class.new)
+      file = File.expand_path( "lwrp/resources/foo.rb", CHEF_SPEC_DATA)
+      expect(Chef::Log).not_to receive(:info).with(/Skipping/)
+      expect(Chef::Log).not_to receive(:debug).with(/anymore/)
+      Chef::Resource::LWRPBase.build_from_file("lwrp", file, nil)
+      Object.send(:remove_const, 'LwrpFoo')
+      Chef::Resource.send(:remove_const, 'LwrpFoo')
+    end
+
+    it "should not skip loading a provider when there's a top level symbol of the same name" do
+      Object.const_set('LwrpBuckPasser', Class.new)
+      file = File.expand_path( "lwrp/providers/buck_passer.rb", CHEF_SPEC_DATA)
+      expect(Chef::Log).not_to receive(:info).with(/Skipping/)
+      expect(Chef::Log).not_to receive(:debug).with(/anymore/)
+      Chef::Provider::LWRPBase.build_from_file("lwrp", file, nil)
+      Object.send(:remove_const, 'LwrpBuckPasser')
+      Chef::Provider.send(:remove_const, 'LwrpBuckPasser')
+    end
+
+    # @todo: we need a before block to manually remove_const all of the LWRPs that we
+    #        load in these tests.  we're threading state through these tests in LWRPs that
+    #        have already been loaded in prior tests, which probably renders some of them bogus
+
     it "should log if attempting to load resource of same name" do
       Dir[File.expand_path( "lwrp/resources/*", CHEF_SPEC_DATA)].each do |file|
         Chef::Resource::LWRPBase.build_from_file("lwrp", file, nil)
       end
 
       Dir[File.expand_path( "lwrp/resources/*", CHEF_SPEC_DATA)].each do |file|
-        Chef::Log.should_receive(:info).with(/Skipping/)
-        Chef::Log.should_receive(:debug).with(/anymore/)
+        expect(Chef::Log).to receive(:info).with(/Skipping/)
+        expect(Chef::Log).to receive(:debug).with(/anymore/)
         Chef::Resource::LWRPBase.build_from_file("lwrp", file, nil)
       end
     end
@@ -54,8 +78,8 @@ describe "LWRP" do
       end
 
       Dir[File.expand_path( "lwrp/providers/*", CHEF_SPEC_DATA)].each do |file|
-        Chef::Log.should_receive(:info).with(/Skipping/)
-        Chef::Log.should_receive(:debug).with(/anymore/)
+        expect(Chef::Log).to receive(:info).with(/Skipping/)
+        expect(Chef::Log).to receive(:debug).with(/anymore/)
         Chef::Provider::LWRPBase.build_from_file("lwrp", file, nil)
       end
     end
@@ -67,11 +91,11 @@ describe "LWRP" do
         Chef::Resource::LWRPBase.build_from_file("lwrp", file, nil)
       end
       first_lwr_foo_class = Chef::Resource::LwrpFoo
-      Chef::Resource.resource_classes.should include(first_lwr_foo_class)
+      expect(Chef::Resource.resource_classes).to include(first_lwr_foo_class)
       Dir[File.expand_path( "lwrp/resources/*", CHEF_SPEC_DATA)].each do |file|
         Chef::Resource::LWRPBase.build_from_file("lwrp", file, nil)
       end
-      Chef::Resource.resource_classes.should include(first_lwr_foo_class)
+      expect(Chef::Resource.resource_classes).to include(first_lwr_foo_class)
     end
 
     it "does not attempt to remove classes from higher up namespaces [CHEF-4117]" do
@@ -95,27 +119,27 @@ describe "LWRP" do
     end
 
     it "should load the resource into a properly-named class" do
-      Chef::Resource.const_get("LwrpFoo").should be_kind_of(Class)
+      expect(Chef::Resource.const_get("LwrpFoo")).to be_kind_of(Class)
     end
 
     it "should set resource_name" do
-      Chef::Resource::LwrpFoo.new("blah").resource_name.should eql(:lwrp_foo)
+      expect(Chef::Resource::LwrpFoo.new("blah").resource_name).to eql(:lwrp_foo)
     end
 
     it "should add the specified actions to the allowed_actions array" do
-      Chef::Resource::LwrpFoo.new("blah").allowed_actions.should include(:pass_buck, :twiddle_thumbs)
+      expect(Chef::Resource::LwrpFoo.new("blah").allowed_actions).to include(:pass_buck, :twiddle_thumbs)
     end
 
     it "should set the specified action as the default action" do
-      Chef::Resource::LwrpFoo.new("blah").action.should == :pass_buck
+      expect(Chef::Resource::LwrpFoo.new("blah").action).to eq(:pass_buck)
     end
 
     it "should create a method for each attribute" do
-      Chef::Resource::LwrpFoo.new("blah").methods.map{ |m| m.to_sym}.should include(:monkey)
+      expect(Chef::Resource::LwrpFoo.new("blah").methods.map{ |m| m.to_sym}).to include(:monkey)
     end
 
     it "should build attribute methods that respect validation rules" do
-      lambda { Chef::Resource::LwrpFoo.new("blah").monkey(42) }.should raise_error(ArgumentError)
+      expect { Chef::Resource::LwrpFoo.new("blah").monkey(42) }.to raise_error(ArgumentError)
     end
 
     it "should have access to the run context and node during class definition" do
@@ -128,9 +152,9 @@ describe "LWRP" do
       end
 
       cls = Chef::Resource.const_get("LwrpNodeattr")
-      cls.node.should be_kind_of(Chef::Node)
-      cls.run_context.should be_kind_of(Chef::RunContext)
-      cls.node[:penguin_name].should eql("jackass")
+      expect(cls.node).to be_kind_of(Chef::Node)
+      expect(cls.run_context).to be_kind_of(Chef::RunContext)
+      expect(cls.node[:penguin_name]).to eql("jackass")
     end
 
     context "resource_name" do
@@ -247,7 +271,7 @@ describe "LWRP" do
           end
         end
 
-        it "ammends actions when they are already defined" do
+        it "amends actions when they are already defined" do
           raise_if_deprecated!
           expect(child.actions).to eq([:eat, :sleep, :drink])
         end
@@ -296,13 +320,13 @@ describe "LWRP" do
     end
 
     it "should load the provider into a properly-named class" do
-      Chef::Provider.const_get("LwrpBuckPasser").should be_kind_of(Class)
+      expect(Chef::Provider.const_get("LwrpBuckPasser")).to be_kind_of(Class)
     end
 
     it "should create a method for each attribute" do
       new_resource = double("new resource").as_null_object
-      Chef::Provider::LwrpBuckPasser.new(nil, new_resource).methods.map{|m|m.to_sym}.should include(:action_pass_buck)
-      Chef::Provider::LwrpThumbTwiddler.new(nil, new_resource).methods.map{|m|m.to_sym}.should include(:action_twiddle_thumbs)
+      expect(Chef::Provider::LwrpBuckPasser.new(nil, new_resource).methods.map{|m|m.to_sym}).to include(:action_pass_buck)
+      expect(Chef::Provider::LwrpThumbTwiddler.new(nil, new_resource).methods.map{|m|m.to_sym}).to include(:action_twiddle_thumbs)
     end
 
     it "should insert resources embedded in the provider into the middle of the resource collection" do
@@ -316,10 +340,10 @@ describe "LWRP" do
 
       Chef::Runner.new(@run_context).converge
 
-      @run_context.resource_collection[0].should eql(injector)
-      @run_context.resource_collection[1].name.should eql(:prepared_thumbs)
-      @run_context.resource_collection[2].name.should eql(:twiddled_thumbs)
-      @run_context.resource_collection[3].should eql(dummy)
+      expect(@run_context.resource_collection[0]).to eql(injector)
+      expect(@run_context.resource_collection[1].name).to eql('prepared_thumbs')
+      expect(@run_context.resource_collection[2].name).to eql('twiddled_thumbs')
+      expect(@run_context.resource_collection[3]).to eql(dummy)
     end
 
     it "should insert embedded resources from multiple providers, including from the last position, properly into the resource collection" do
@@ -340,13 +364,13 @@ describe "LWRP" do
 
       Chef::Runner.new(@run_context).converge
 
-      @run_context.resource_collection[0].should eql(injector)
-      @run_context.resource_collection[1].name.should eql(:prepared_thumbs)
-      @run_context.resource_collection[2].name.should eql(:twiddled_thumbs)
-      @run_context.resource_collection[3].should eql(dummy)
-      @run_context.resource_collection[4].should eql(injector2)
-      @run_context.resource_collection[5].name.should eql(:prepared_eyes)
-      @run_context.resource_collection[6].name.should eql(:dried_paint_watched)
+      expect(@run_context.resource_collection[0]).to eql(injector)
+      expect(@run_context.resource_collection[1].name).to eql('prepared_thumbs')
+      expect(@run_context.resource_collection[2].name).to eql('twiddled_thumbs')
+      expect(@run_context.resource_collection[3]).to eql(dummy)
+      expect(@run_context.resource_collection[4]).to eql(injector2)
+      expect(@run_context.resource_collection[5].name).to eql('prepared_eyes')
+      expect(@run_context.resource_collection[6].name).to eql('dried_paint_watched')
     end
 
     it "should properly handle a new_resource reference" do
@@ -357,7 +381,7 @@ describe "LWRP" do
       provider = Chef::Platform.provider_for_resource(resource, :twiddle_thumbs)
       provider.action_twiddle_thumbs
 
-      provider.monkey_name.should == "my monkey's name is 'bob'"
+      expect(provider.monkey_name).to eq("my monkey's name is 'bob'")
     end
 
     it "should properly handle an embedded Resource accessing the enclosing Provider's scope" do
@@ -369,7 +393,7 @@ describe "LWRP" do
       #provider = @runner.build_provider(resource)
       provider.action_twiddle_thumbs
 
-      provider.enclosed_resource.monkey.should == 'bob, the monkey'
+      expect(provider.enclosed_resource.monkey).to eq('bob, the monkey')
     end
 
     describe "when using inline compilation" do
@@ -388,27 +412,27 @@ describe "LWRP" do
 
       it "does not add interior resources to the exterior resource collection" do
         @resource.run_action(:test)
-        @run_context.resource_collection.should be_empty
+        expect(@run_context.resource_collection).to be_empty
       end
 
       context "when interior resources are updated" do
         it "processes notifications within the LWRP provider's action" do
           @resource.run_action(:test)
-          $interior_ruby_block_2.should == "executed"
+          expect($interior_ruby_block_2).to eq("executed")
         end
 
         it "marks the parent resource updated" do
           @resource.run_action(:test)
-          @resource.should be_updated
-          @resource.should be_updated_by_last_action
+          expect(@resource).to be_updated
+          expect(@resource).to be_updated_by_last_action
         end
       end
 
       context "when interior resources are not updated" do
         it "does not mark the parent resource updated" do
           @resource.run_action(:no_updates)
-          @resource.should_not be_updated
-          @resource.should_not be_updated_by_last_action
+          expect(@resource).not_to be_updated
+          expect(@resource).not_to be_updated_by_last_action
         end
       end
 

data/spec/unit/mash_spec.rb

@@ -24,27 +24,27 @@ describe Mash do
     data = {:x=>"one", :y=>"two", :z=>"three"}
     @orig = Mash.new(data)
     @copy = @orig.dup
-    @copy.to_hash.should == Mash.new(data).to_hash
+    expect(@copy.to_hash).to eq(Mash.new(data).to_hash)
     @copy[:x] = "four"
-    @orig[:x].should == "one"
+    expect(@orig[:x]).to eq("one")
   end
 
   it "should duplicate a mash with an array to a new mash" do
     data = {:x=>"one", :y=>"two", :z=>[1,2,3]}
     @orig = Mash.new(data)
     @copy = @orig.dup
-    @copy.to_hash.should == Mash.new(data).to_hash
+    expect(@copy.to_hash).to eq(Mash.new(data).to_hash)
     @copy[:z] << 4
-    @orig[:z].should == [1,2,3]
+    expect(@orig[:z]).to eq([1,2,3])
   end
 
   it "should duplicate a nested mash to a new mash" do
     data = {:x=>"one", :y=>"two", :z=>Mash.new({:a=>[1,2,3]})}
     @orig = Mash.new(data)
     @copy = @orig.dup
-    @copy.to_hash.should == Mash.new(data).to_hash
+    expect(@copy.to_hash).to eq(Mash.new(data).to_hash)
     @copy[:z][:a] << 4
-    @orig[:z][:a].should == [1,2,3]
+    expect(@orig[:z][:a]).to eq([1,2,3])
   end
 
   # add more!