chef 12.0.0.alpha.2-x86-mingw32 → 12.0.0.rc.0-x86-mingw32

data/spec/unit/resource/apt_package_spec.rb

@@ -17,27 +17,24 @@
 #
 
 require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
 
 describe Chef::Resource::AptPackage, "initialize" do
 
+  static_provider_resolution(
+    resource: Chef::Resource::AptPackage,
+    provider: Chef::Provider::Package::Apt,
+    name: :apt_package,
+    action: :install,
+    os: "linux",
+  )
+
   before(:each) do
     @resource = Chef::Resource::AptPackage.new("foo")
   end
 
-  it "should return a Chef::Resource::AptPackage" do
-    @resource.should be_a_kind_of(Chef::Resource::AptPackage)
-  end
-
-  it "should set the resource_name to :apt_package" do
-    @resource.resource_name.should eql(:apt_package)
-  end
-
-  it "should set the provider to Chef::Provider::Package::Apt" do
-    @resource.provider.should eql(Chef::Provider::Package::Apt)
-  end
-
   it "should support default_release" do
     @resource.default_release("lenny-backports")
-    @resource.default_release.should eql("lenny-backports")
+    expect(@resource.default_release).to eql("lenny-backports")
   end
 end

data/spec/unit/resource/bash_spec.rb

@@ -25,16 +25,16 @@ describe Chef::Resource::Bash do
   end
 
   it "should create a new Chef::Resource::Bash" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Bash)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Bash)
   end
 
   it "should have a resource name of :bash" do
-    @resource.resource_name.should eql(:bash)
+    expect(@resource.resource_name).to eql(:bash)
   end
 
   it "should have an interpreter of bash" do
-    @resource.interpreter.should eql("bash")
+    expect(@resource.interpreter).to eql("bash")
   end
 
 end

data/spec/unit/resource/batch_spec.rb

@@ -33,7 +33,7 @@ describe Chef::Resource::Batch do
   end
 
   it "should create a new Chef::Resource::Batch" do
-    @resource.should be_a_kind_of(Chef::Resource::Batch)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Batch)
   end
 
   context "windows script" do

data/spec/unit/resource/breakpoint_spec.rb

@@ -17,27 +17,31 @@
 #
 
 require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
 
 describe Chef::Resource::Breakpoint do
 
+  static_provider_resolution(
+    resource: Chef::Resource::Breakpoint,
+    provider: Chef::Provider::Breakpoint,
+    name: :breakpoint,
+    action: :break,
+  )
+
   before do
     @breakpoint = Chef::Resource::Breakpoint.new
   end
 
   it "allows the action :break" do
-    @breakpoint.allowed_actions.should include(:break)
+    expect(@breakpoint.allowed_actions).to include(:break)
   end
 
   it "defaults to the break action" do
-    @breakpoint.action.should == "break"
+    expect(@breakpoint.action).to eq("break")
   end
 
   it "names itself after the line number of the file where it's created" do
-    @breakpoint.name.should match(/breakpoint_spec\.rb\:[\d]{2}\:in \`new\'$/)
-  end
-
-  it "uses the breakpoint provider" do
-    @breakpoint.provider.should == Chef::Provider::Breakpoint
+    expect(@breakpoint.name).to match(/breakpoint_spec\.rb\:[\d]{2}\:in \`new\'$/)
   end
 
 end

data/spec/unit/resource/chef_gem_spec.rb

@@ -18,24 +18,17 @@
 #
 
 require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
 
 describe Chef::Resource::ChefGem, "initialize" do
 
-  before(:each) do
-    @resource = Chef::Resource::ChefGem.new("foo")
-  end
-
-  it "should return a Chef::Resource::ChefGem" do
-    @resource.should be_a_kind_of(Chef::Resource::ChefGem)
-  end
-
-  it "should set the resource_name to :chef_gem" do
-    @resource.resource_name.should eql(:chef_gem)
-  end
+  static_provider_resolution(
+    resource: Chef::Resource::ChefGem,
+    provider: Chef::Provider::Package::Rubygems,
+    name: :chef_gem,
+    action: :install,
+  )
 
-  it "should set the provider to Chef::Provider::Package::Rubygems" do
-    @resource.provider.should eql(Chef::Provider::Package::Rubygems)
-  end
 end
 
 describe Chef::Resource::ChefGem, "gem_binary" do
@@ -45,7 +38,7 @@ describe Chef::Resource::ChefGem, "gem_binary" do
   end
 
   it "should raise an exception when gem_binary is set" do
-    lambda { @resource.gem_binary("/lol/cats/gem") }.should raise_error(ArgumentError)
+    expect { @resource.gem_binary("/lol/cats/gem") }.to raise_error(ArgumentError)
   end
 
   it "should set the gem_binary based on computing it from RbConfig" do

data/spec/unit/resource/conditional_action_not_nothing_spec.rb

@@ -27,7 +27,7 @@ describe Chef::Resource::ConditionalActionNotNothing do
     end
 
     it "indicates that resource convergence should not continue" do
-      @conditional.continue?.should be_false
+      expect(@conditional.continue?).to be_false
     end
   end
 
@@ -38,7 +38,7 @@ describe Chef::Resource::ConditionalActionNotNothing do
     end
 
     it "indicates that resource convergence should continue" do
-      @conditional.continue?.should be_true
+      expect(@conditional.continue?).to be_true
     end
   end
 

data/spec/unit/resource/conditional_spec.rb

@@ -21,12 +21,31 @@ require 'ostruct'
 
 describe Chef::Resource::Conditional do
   before do
-    Mixlib::ShellOut.any_instance.stub(:run_command).and_return(nil)
+    allow_any_instance_of(Mixlib::ShellOut).to receive(:run_command).and_return(nil)
     @status = OpenStruct.new(:success? => true)
-    Mixlib::ShellOut.any_instance.stub(:status).and_return(@status)
+    allow_any_instance_of(Mixlib::ShellOut).to receive(:status).and_return(@status)
     @parent_resource = Chef::Resource.new(nil, Chef::Node.new)
   end
 
+  it "raises an exception when neither a block or command is given" do
+    expect { Chef::Resource::Conditional.send(:new, :always, @parent_resource, nil, {})}.to raise_error(ArgumentError, /requires either a command or a block/)
+  end
+
+  it "does not evaluate a guard interpreter on initialization of the conditional" do
+    expect_any_instance_of(Chef::Resource::Conditional).not_to receive(:configure)
+    expect(Chef::GuardInterpreter::DefaultGuardInterpreter).not_to receive(:new)
+    expect(Chef::GuardInterpreter::ResourceGuardInterpreter).not_to receive(:new)
+    Chef::Resource::Conditional.only_if(@parent_resource, "true")
+  end
+
+  describe "configure" do
+    it "raises an exception when a guard_interpreter is specified and a block is given" do
+      @parent_resource.guard_interpreter :canadian_mounties
+      conditional = Chef::Resource::Conditional.send(:new, :always, @parent_resource, nil, {}) { True }
+      expect { conditional.configure }.to raise_error(ArgumentError, /does not support blocks/)
+    end
+  end
+
   describe "when created as an `only_if`" do
     describe "after running a successful command" do
       before do
@@ -34,7 +53,7 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should continue" do
-        @conditional.continue?.should be_true
+        expect(@conditional.continue?).to be_true
       end
     end
 
@@ -45,22 +64,22 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should not continue" do
-        @conditional.continue?.should be_false
+        expect(@conditional.continue?).to be_false
       end
     end
 
     describe 'after running a command which timed out' do
       before do
         @conditional = Chef::Resource::Conditional.only_if(@parent_resource, "false")
-        Chef::GuardInterpreter::DefaultGuardInterpreter.any_instance.stub(:shell_out).and_raise(Chef::Exceptions::CommandTimeout)
+        allow_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).to receive(:shell_out).and_raise(Chef::Exceptions::CommandTimeout)
       end
 
       it 'indicates that resource convergence should not continue' do
-        @conditional.continue?.should be_false
+        expect(@conditional.continue?).to be_false
       end
 
       it 'should log a warning' do
-        Chef::Log.should_receive(:warn).with("Command 'false' timed out")
+        expect(Chef::Log).to receive(:warn).with("Command 'false' timed out")
         @conditional.continue?
       end
     end
@@ -71,7 +90,7 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should continue" do
-        @conditional.continue?.should be_true
+        expect(@conditional.continue?).to be_true
       end
     end
 
@@ -81,7 +100,7 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should not continue" do
-        @conditional.continue?.should be_false
+        expect(@conditional.continue?).to be_false
       end
     end
   end
@@ -93,7 +112,7 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should not continue" do
-        @conditional.continue?.should be_false
+        expect(@conditional.continue?).to be_false
       end
     end
 
@@ -104,22 +123,22 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should continue" do
-        @conditional.continue?.should be_true
+        expect(@conditional.continue?).to be_true
       end
     end
 
     describe 'after running a command which timed out' do
       before do
         @conditional = Chef::Resource::Conditional.not_if(@parent_resource,  "false")
-        Chef::GuardInterpreter::DefaultGuardInterpreter.any_instance.stub(:shell_out).and_raise(Chef::Exceptions::CommandTimeout)
+        allow_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).to receive(:shell_out).and_raise(Chef::Exceptions::CommandTimeout)
       end
 
       it 'indicates that resource convergence should continue' do
-        @conditional.continue?.should be_true
+        expect(@conditional.continue?).to be_true
       end
 
       it 'should log a warning' do
-        Chef::Log.should_receive(:warn).with("Command 'false' timed out")
+        expect(Chef::Log).to receive(:warn).with("Command 'false' timed out")
         @conditional.continue?
       end
     end
@@ -130,7 +149,7 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should not continue" do
-        @conditional.continue?.should be_false
+        expect(@conditional.continue?).to be_false
       end
     end
 
@@ -140,7 +159,7 @@ describe Chef::Resource::Conditional do
       end
 
       it "indicates that resource convergence should continue" do
-        @conditional.continue?.should be_true
+        expect(@conditional.continue?).to be_true
       end
     end
   end

data/spec/unit/resource/cookbook_file_spec.rb

@@ -25,25 +25,25 @@ describe Chef::Resource::CookbookFile do
   end
 
   it "uses the name parameter for the source parameter" do
-    @cookbook_file.name.should == 'sourcecode_tarball.tgz'
+    expect(@cookbook_file.name).to eq('sourcecode_tarball.tgz')
   end
 
   it "has a source parameter" do
     @cookbook_file.name('config_file.conf')
-    @cookbook_file.name.should == 'config_file.conf'
+    expect(@cookbook_file.name).to eq('config_file.conf')
   end
 
   it "defaults to a nil cookbook parameter (current cookbook will be used)" do
-    @cookbook_file.cookbook.should be_nil
+    expect(@cookbook_file.cookbook).to be_nil
   end
 
   it "has a cookbook parameter" do
     @cookbook_file.cookbook("munin")
-    @cookbook_file.cookbook.should == 'munin'
+    expect(@cookbook_file.cookbook).to eq('munin')
   end
 
   it "sets the provider to Chef::Provider::CookbookFile" do
-    @cookbook_file.provider.should == Chef::Provider::CookbookFile
+    expect(@cookbook_file.provider).to eq(Chef::Provider::CookbookFile)
   end
 
   describe "when it has a backup number, group, mode, owner, source, checksum, and cookbook on nix or path, rights, deny_rights, checksum on windows" do
@@ -68,21 +68,21 @@ describe Chef::Resource::CookbookFile do
       state = @cookbook_file.state
       if Chef::Platform.windows?
         puts state
-        state[:rights].should == [{:permissions => :read, :principals => "Everyone"}]
-        state[:deny_rights].should == [{:permissions => :full_control, :principals => "Clumsy_Sam"}]
+        expect(state[:rights]).to eq([{:permissions => :read, :principals => "Everyone"}])
+        expect(state[:deny_rights]).to eq([{:permissions => :full_control, :principals => "Clumsy_Sam"}])
       else
-        state[:group].should == "wheel"
-        state[:mode].should == "0664"
-        state[:owner].should == "root"
+        expect(state[:group]).to eq("wheel")
+        expect(state[:mode]).to eq("0664")
+        expect(state[:owner]).to eq("root")
       end
-      state[:checksum].should == "1" * 64
+      expect(state[:checksum]).to eq("1" * 64)
     end
 
     it "returns the path as its identity" do
       if Chef::Platform.windows?
-        @cookbook_file.identity.should == "C:/temp/origin/file.txt"
+        expect(@cookbook_file.identity).to eq("C:/temp/origin/file.txt")
       else
-        @cookbook_file.identity.should == "/tmp/origin/file.txt"
+        expect(@cookbook_file.identity).to eq("/tmp/origin/file.txt")
       end
     end
   end

data/spec/unit/resource/cron_spec.rb

@@ -26,135 +26,135 @@ describe Chef::Resource::Cron do
   end
 
   it "should create a new Chef::Resource::Cron" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Cron)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Cron)
   end
 
   it "should have a name" do
-    @resource.name.should eql("cronify")
+    expect(@resource.name).to eql("cronify")
   end
 
   it "should have a default action of 'create'" do
-    @resource.action.should eql(:create)
+    expect(@resource.action).to eql(:create)
   end
 
   it "should accept create or delete for action" do
-    lambda { @resource.action :create }.should_not raise_error
-    lambda { @resource.action :delete }.should_not raise_error
-    lambda { @resource.action :lolcat }.should raise_error(ArgumentError)
+    expect { @resource.action :create }.not_to raise_error
+    expect { @resource.action :delete }.not_to raise_error
+    expect { @resource.action :lolcat }.to raise_error(ArgumentError)
   end
 
   it "should allow you to set a command" do
     @resource.command "/bin/true"
-    @resource.command.should eql("/bin/true")
+    expect(@resource.command).to eql("/bin/true")
   end
 
   it "should allow you to set a user" do
     @resource.user "daemon"
-    @resource.user.should eql("daemon")
+    expect(@resource.user).to eql("daemon")
   end
 
   it "should allow you to specify the minute" do
     @resource.minute "30"
-    @resource.minute.should eql("30")
+    expect(@resource.minute).to eql("30")
   end
 
   it "should allow you to specify the hour" do
     @resource.hour "6"
-    @resource.hour.should eql("6")
+    expect(@resource.hour).to eql("6")
   end
 
   it "should allow you to specify the day" do
     @resource.day "10"
-    @resource.day.should eql("10")
+    expect(@resource.day).to eql("10")
   end
 
   it "should allow you to specify the month" do
     @resource.month "10"
-    @resource.month.should eql("10")
+    expect(@resource.month).to eql("10")
   end
 
   it "should allow you to specify the weekday" do
     @resource.weekday "2"
-    @resource.weekday.should eql("2")
+    expect(@resource.weekday).to eql("2")
   end
 
   it "should allow you to specify the mailto variable" do
     @resource.mailto "test@example.com"
-    @resource.mailto.should eql("test@example.com")
+    expect(@resource.mailto).to eql("test@example.com")
   end
 
   it "should allow you to specify the path" do
     @resource.path "/usr/bin:/usr/sbin"
-    @resource.path.should eql("/usr/bin:/usr/sbin")
+    expect(@resource.path).to eql("/usr/bin:/usr/sbin")
   end
 
   it "should allow you to specify the home directory" do
     @resource.home "/root"
-    @resource.home.should eql("/root")
+    expect(@resource.home).to eql("/root")
   end
 
   it "should allow you to specify the shell to run the command with" do
     @resource.shell "/bin/zsh"
-    @resource.shell.should eql("/bin/zsh")
+    expect(@resource.shell).to eql("/bin/zsh")
   end
 
   it "should allow you to specify environment variables hash" do
     env = {"TEST" => "LOL"}
     @resource.environment env
-    @resource.environment.should eql(env)
+    expect(@resource.environment).to eql(env)
   end
 
   it "should allow * for all time and date values" do
     [ "minute", "hour", "day", "month", "weekday" ].each do |x|
-      @resource.send(x, "*").should eql("*")
+      expect(@resource.send(x, "*")).to eql("*")
     end
   end
 
   it "should allow ranges for all time and date values" do
     [ "minute", "hour", "day", "month", "weekday" ].each do |x|
-      @resource.send(x, "1-2,5").should eql("1-2,5")
+      expect(@resource.send(x, "1-2,5")).to eql("1-2,5")
     end
   end
 
   it "should have a default value of * for all time and date values" do
     [ "minute", "hour", "day", "month", "weekday" ].each do |x|
-      @resource.send(x).should eql("*")
+      expect(@resource.send(x)).to eql("*")
     end
   end
 
   it "should have a default value of root for the user" do
-    @resource.user.should eql("root")
+    expect(@resource.user).to eql("root")
   end
 
   it "should reject any minute over 59" do
-    lambda { @resource.minute "60" }.should raise_error(RangeError)
+    expect { @resource.minute "60" }.to raise_error(RangeError)
   end
 
   it "should reject any hour over 23" do
-    lambda { @resource.hour "24" }.should raise_error(RangeError)
+    expect { @resource.hour "24" }.to raise_error(RangeError)
   end
 
   it "should reject any day over 31" do
-    lambda { @resource.day "32" }.should raise_error(RangeError)
+    expect { @resource.day "32" }.to raise_error(RangeError)
   end
 
   it "should reject any month over 12" do
-    lambda { @resource.month "13" }.should raise_error(RangeError)
+    expect { @resource.month "13" }.to raise_error(RangeError)
   end
 
   describe "weekday" do
     it "should reject any weekday over 7" do
-      lambda { @resource.weekday "8" }.should raise_error(RangeError)
+      expect { @resource.weekday "8" }.to raise_error(RangeError)
     end
     it "should reject any symbols which don't represent day of week" do
-      lambda { @resource.weekday :foo }.should raise_error(RangeError)
+      expect { @resource.weekday :foo }.to raise_error(RangeError)
     end
   end
 
   it "should convert integer schedule values to a string" do
     [ "minute", "hour", "day", "month", "weekday" ].each do |x|
-      @resource.send(x, 5).should eql("5")
+      expect(@resource.send(x, 5)).to eql("5")
     end
   end
 
@@ -171,16 +171,16 @@ describe Chef::Resource::Cron do
 
     it "describes the state" do
       state = @resource.state
-      state[:minute].should == "1"
-      state[:hour].should == "2"
-      state[:day].should == "3"
-      state[:month].should == "4"
-      state[:weekday].should == "5"
-      state[:user].should == "root"
+      expect(state[:minute]).to eq("1")
+      expect(state[:hour]).to eq("2")
+      expect(state[:day]).to eq("3")
+      expect(state[:month]).to eq("4")
+      expect(state[:weekday]).to eq("5")
+      expect(state[:user]).to eq("root")
     end
 
     it "returns the command as its identity" do
-      @resource.identity.should == "tackle"
+      expect(@resource.identity).to eq("tackle")
     end
   end
 end