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

data/spec/unit/resource/mount_spec.rb

@@ -25,150 +25,150 @@ describe Chef::Resource::Mount do
   end
 
   it "should create a new Chef::Resource::Mount" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Mount)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Mount)
   end
 
   it "should have a name" do
-    @resource.name.should eql("filesystem")
+    expect(@resource.name).to eql("filesystem")
   end
 
   it "should set mount_point to the name" do
-    @resource.mount_point.should eql("filesystem")
+    expect(@resource.mount_point).to eql("filesystem")
   end
 
   it "should have a default action of mount" do
-    @resource.action.should eql(:mount)
+    expect(@resource.action).to eql(:mount)
   end
 
   it "should accept mount, umount and remount as actions" do
-    lambda { @resource.action :mount }.should_not raise_error
-    lambda { @resource.action :umount }.should_not raise_error
-    lambda { @resource.action :remount }.should_not raise_error
-    lambda { @resource.action :brooklyn }.should raise_error(ArgumentError)
+    expect { @resource.action :mount }.not_to raise_error
+    expect { @resource.action :umount }.not_to raise_error
+    expect { @resource.action :remount }.not_to raise_error
+    expect { @resource.action :brooklyn }.to raise_error(ArgumentError)
   end
 
   it "should allow you to set the device attribute" do
     @resource.device "/dev/sdb3"
-    @resource.device.should eql("/dev/sdb3")
+    expect(@resource.device).to eql("/dev/sdb3")
   end
 
   it "should set fsck_device to '-' by default" do
-    @resource.fsck_device.should eql('-')
+    expect(@resource.fsck_device).to eql('-')
   end
 
   it "should allow you to set the fsck_device attribute" do
     @resource.fsck_device "/dev/rdsk/sdb3"
-    @resource.fsck_device.should eql("/dev/rdsk/sdb3")
+    expect(@resource.fsck_device).to eql("/dev/rdsk/sdb3")
   end
 
   it "should allow you to set the fstype attribute" do
     @resource.fstype "nfs"
-    @resource.fstype.should eql("nfs")
+    expect(@resource.fstype).to eql("nfs")
   end
 
   it "should allow you to set the dump attribute" do
     @resource.dump 1
-    @resource.dump.should eql(1)
+    expect(@resource.dump).to eql(1)
   end
 
   it "should allow you to set the pass attribute" do
     @resource.pass 1
-    @resource.pass.should eql(1)
+    expect(@resource.pass).to eql(1)
   end
 
   it "should set the options attribute to defaults" do
-    @resource.options.should eql(["defaults"])
+    expect(@resource.options).to eql(["defaults"])
   end
 
   it "should allow options to be sent as a string, and convert to array" do
     @resource.options "rw,noexec"
-    @resource.options.should be_a_kind_of(Array)
+    expect(@resource.options).to be_a_kind_of(Array)
   end
 
   it "should allow options attribute as an array" do
     @resource.options ["ro", "nosuid"]
-    @resource.options.should be_a_kind_of(Array)
+    expect(@resource.options).to be_a_kind_of(Array)
   end
 
   it "should allow options to be sent as a delayed evaluator" do
     @resource.options Chef::DelayedEvaluator.new {["rw", "noexec"]}
-    @resource.options.should eql(["rw", "noexec"])
+    expect(@resource.options).to eql(["rw", "noexec"])
   end
 
   it "should allow options to be sent as a delayed evaluator, and convert to array" do
     @resource.options Chef::DelayedEvaluator.new {"rw,noexec"}
-    @resource.options.should be_a_kind_of(Array)
-    @resource.options.should eql(["rw", "noexec"])
+    expect(@resource.options).to be_a_kind_of(Array)
+    expect(@resource.options).to eql(["rw", "noexec"])
   end
 
   it "should accept true for mounted" do
     @resource.mounted(true)
-    @resource.mounted.should eql(true)
+    expect(@resource.mounted).to eql(true)
   end
 
   it "should accept false for mounted" do
     @resource.mounted(false)
-    @resource.mounted.should eql(false)
+    expect(@resource.mounted).to eql(false)
   end
 
   it "should set mounted to false by default" do
-    @resource.mounted.should eql(false)
+    expect(@resource.mounted).to eql(false)
   end
 
   it "should not accept a string for mounted" do
-    lambda { @resource.mounted("poop") }.should raise_error(ArgumentError)
+    expect { @resource.mounted("poop") }.to raise_error(ArgumentError)
   end
 
   it "should accept true for enabled" do
     @resource.enabled(true)
-    @resource.enabled.should eql(true)
+    expect(@resource.enabled).to eql(true)
   end
 
   it "should accept false for enabled" do
     @resource.enabled(false)
-    @resource.enabled.should eql(false)
+    expect(@resource.enabled).to eql(false)
   end
 
   it "should set enabled to false by default" do
-    @resource.enabled.should eql(false)
+    expect(@resource.enabled).to eql(false)
   end
 
   it "should not accept a string for enabled" do
-    lambda { @resource.enabled("poop") }.should raise_error(ArgumentError)
+    expect { @resource.enabled("poop") }.to raise_error(ArgumentError)
   end
 
   it "should default all feature support to false" do
     support_hash = { :remount => false }
-    @resource.supports.should == support_hash
+    expect(@resource.supports).to eq(support_hash)
   end
 
   it "should allow you to set feature support as an array" do
     support_array = [ :remount ]
     support_hash = { :remount => true }
     @resource.supports(support_array)
-    @resource.supports.should == support_hash
+    expect(@resource.supports).to eq(support_hash)
   end
 
   it "should allow you to set feature support as a hash" do
     support_hash = { :remount => true }
     @resource.supports(support_hash)
-    @resource.supports.should == support_hash
+    expect(@resource.supports).to eq(support_hash)
   end
 
   it "should allow you to set username" do
     @resource.username("Administrator")
-    @resource.username.should == "Administrator"
+    expect(@resource.username).to eq("Administrator")
   end
 
   it "should allow you to set password" do
     @resource.password("Jetstream123!")
-    @resource.password.should == "Jetstream123!"
+    expect(@resource.password).to eq("Jetstream123!")
   end
 
   it "should allow you to set domain" do
     @resource.domain("TEST_DOMAIN")
-    @resource.domain.should == "TEST_DOMAIN"
+    expect(@resource.domain).to eq("TEST_DOMAIN")
   end
 
   describe "when it has mount point, device type, and fstype" do
@@ -181,13 +181,13 @@ describe Chef::Resource::Mount do
 
     it "describes its state" do
       state = @resource.state
-      state[:mount_point].should == "123.456"
-      state[:device_type].should eql(:device)
-      state[:fstype].should == "ranked"
+      expect(state[:mount_point]).to eq("123.456")
+      expect(state[:device_type]).to eql(:device)
+      expect(state[:fstype]).to eq("ranked")
     end
 
     it "returns the device as its identity" do
-      @resource.identity.should == "charmander"
+      expect(@resource.identity).to eq("charmander")
     end
   end
 
@@ -202,12 +202,12 @@ describe Chef::Resource::Mount do
 
     it "describes its state" do
       state = @resource.state
-      state[:mount_point].should == "T:"
-      state[:username].should == "Administrator"
-      state[:password].should == "Jetstream123!"
-      state[:domain].should == "TEST_DOMAIN"
-      state[:device_type].should eql(:device)
-      state[:fstype].should == "auto"
+      expect(state[:mount_point]).to eq("T:")
+      expect(state[:username]).to eq("Administrator")
+      expect(state[:password]).to eq("Jetstream123!")
+      expect(state[:domain]).to eq("TEST_DOMAIN")
+      expect(state[:device_type]).to eql(:device)
+      expect(state[:fstype]).to eq("auto")
     end
 
   end

data/spec/unit/resource/ohai_spec.rb

@@ -25,21 +25,21 @@ describe Chef::Resource::Ohai do
   end
 
   it "should create a new Chef::Resource::Ohai" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Ohai)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Ohai)
   end
 
   it "should have a resource name of :ohai" do
-    @resource.resource_name.should eql(:ohai)
+    expect(@resource.resource_name).to eql(:ohai)
   end
 
   it "should have a default action of create" do
-    @resource.action.should eql(:reload)
+    expect(@resource.action).to eql(:reload)
   end
 
   it "should allow you to set the plugin attribute" do
     @resource.plugin "passwd"
-    @resource.plugin.should eql("passwd")
+    expect(@resource.plugin).to eql("passwd")
   end
 
   describe "when it has a plugin value" do
@@ -50,11 +50,11 @@ describe Chef::Resource::Ohai do
 
     it "describes its state" do
       state = @resource.state
-      state[:plugin].should == "passwd"
+      expect(state[:plugin]).to eq("passwd")
     end
 
     it "returns the name as its identity" do
-      @resource.identity.should == "test"
+      expect(@resource.identity).to eq("test")
     end
   end
 

data/spec/unit/resource/package_spec.rb

@@ -26,42 +26,42 @@ describe Chef::Resource::Package do
   end
 
   it "should create a new Chef::Resource::Package" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Package)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Package)
   end
 
   it "should set the package_name to the first argument to new" do
-    @resource.package_name.should eql("emacs")
+    expect(@resource.package_name).to eql("emacs")
   end
 
   it "should accept a string for the package name" do
     @resource.package_name "something"
-    @resource.package_name.should eql("something")
+    expect(@resource.package_name).to eql("something")
   end
 
   it "should accept a string for the version" do
     @resource.version "something"
-    @resource.version.should eql("something")
+    expect(@resource.version).to eql("something")
   end
 
   it "should accept a string for the response file" do
     @resource.response_file "something"
-    @resource.response_file.should eql("something")
+    expect(@resource.response_file).to eql("something")
   end
 
   it "should accept a hash for response file template variables" do
     @resource.response_file_variables({:variables => true})
-    @resource.response_file_variables.should eql({:variables => true})
+    expect(@resource.response_file_variables).to eql({:variables => true})
   end
 
   it "should accept a string for the source" do
     @resource.source "something"
-    @resource.source.should eql("something")
+    expect(@resource.source).to eql("something")
   end
 
   it "should accept a string for the options" do
     @resource.options "something"
-    @resource.options.should eql("something")
+    expect(@resource.options).to eql("something")
   end
 
   describe "when it has a package_name and version" do
@@ -73,12 +73,12 @@ describe Chef::Resource::Package do
 
     it "describes its state" do
       state = @resource.state
-      state[:version].should == "10.9.8"
-      state[:options].should == "-al"
+      expect(state[:version]).to eq("10.9.8")
+      expect(state[:options]).to eq("-al")
     end
 
     it "returns the file path as its identity" do
-      @resource.identity.should == "tomcat"
+      expect(@resource.identity).to eq("tomcat")
     end
   end
 

data/spec/unit/resource/pacman_package_spec.rb

@@ -17,22 +17,16 @@
 #
 
 require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
 
 describe Chef::Resource::PacmanPackage, "initialize" do
 
-  before(:each) do
-    @resource = Chef::Resource::PacmanPackage.new("foo")
-  end
+  static_provider_resolution(
+    resource: Chef::Resource::PacmanPackage,
+    provider: Chef::Provider::Package::Pacman,
+    name: :pacman_package,
+    action: :install,
+    os: "linux",
+  )
 
-  it "should return a Chef::Resource::PacmanPackage" do
-    @resource.should be_a_kind_of(Chef::Resource::PacmanPackage)
-  end
-
-  it "should set the resource_name to :pacman_package" do
-    @resource.resource_name.should eql(:pacman_package)
-  end
-
-  it "should set the provider to Chef::Provider::Package::Pacman" do
-    @resource.provider.should eql(Chef::Provider::Package::Pacman)
-  end
 end

data/spec/unit/resource/perl_spec.rb

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

data/spec/unit/resource/portage_package_spec.rb

@@ -25,14 +25,14 @@ describe Chef::Resource::PortagePackage, "initialize" do
   end
 
   it "should return a Chef::Resource::PortagePackage" do
-    @resource.should be_a_kind_of(Chef::Resource::PortagePackage)
+    expect(@resource).to be_a_kind_of(Chef::Resource::PortagePackage)
   end
 
   it "should set the resource_name to :portage_package" do
-    @resource.resource_name.should eql(:portage_package)
+    expect(@resource.resource_name).to eql(:portage_package)
   end
 
   it "should set the provider to Chef::Provider::Package::Portage" do
-    @resource.provider.should eql(Chef::Provider::Package::Portage)
+    expect(@resource.provider).to eql(Chef::Provider::Package::Portage)
   end
 end

data/spec/unit/resource/powershell_spec.rb

@@ -33,32 +33,32 @@ describe Chef::Resource::PowershellScript do
   end
 
   it "should create a new Chef::Resource::PowershellScript" do
-    @resource.should be_a_kind_of(Chef::Resource::PowershellScript)
+    expect(@resource).to be_a_kind_of(Chef::Resource::PowershellScript)
   end
 
   it "should set convert_boolean_return to false by default" do
-    @resource.convert_boolean_return.should == false
+    expect(@resource.convert_boolean_return).to eq(false)
   end
 
   it "should return the value for convert_boolean_return that was set" do
     @resource.convert_boolean_return true
-    @resource.convert_boolean_return.should == true
+    expect(@resource.convert_boolean_return).to eq(true)
     @resource.convert_boolean_return false
-    @resource.convert_boolean_return.should == false
+    expect(@resource.convert_boolean_return).to eq(false)
   end
 
   context "when using guards" do
     let(:resource) { @resource }
     before(:each) do
-      resource.stub(:run_action)
-      resource.stub(:updated).and_return(true)
+      allow(resource).to receive(:run_action)
+      allow(resource).to receive(:updated).and_return(true)
     end
 
     it "inherits exactly the :cwd, :environment, :group, :path, :user, :umask, and :architecture attributes from a parent resource class" do
       inherited_difference = Chef::Resource::PowershellScript.guard_inherited_attributes -
         [:cwd, :environment, :group, :path, :user, :umask, :architecture ]
 
-      inherited_difference.should == []
+      expect(inherited_difference).to eq([])
     end
 
     it "should allow guard interpreter to be set to Chef::Resource::Script" do

data/spec/unit/resource/python_spec.rb

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