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

data/spec/unit/resource/easy_install_package_spec.rb

@@ -17,32 +17,23 @@
 #
 
 require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
 
 describe Chef::Resource::EasyInstallPackage, "initialize" do
 
+  static_provider_resolution(
+    resource: Chef::Resource::EasyInstallPackage,
+    provider: Chef::Provider::Package::EasyInstall,
+    name: :easy_install_package,
+    action: :install,
+  )
+
   before(:each) do
     @resource = Chef::Resource::EasyInstallPackage.new("foo")
   end
 
-  it "should create a new Chef::Resource::EasyInstallPackage" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::EasyInstallPackage)
-  end
-
-  it "should return a Chef::Resource::EasyInstallPackage" do
-    @resource.should be_a_kind_of(Chef::Resource::EasyInstallPackage)
-  end
-
-  it "should set the resource_name to :easy_install_package" do
-    @resource.resource_name.should eql(:easy_install_package)
-  end
-
-  it "should set the provider to Chef::Provider::Package::EasyInstall" do
-    @resource.provider.should eql(Chef::Provider::Package::EasyInstall)
-  end
-
   it "should allow you to set the easy_install_binary attribute" do
     @resource.easy_install_binary "/opt/local/bin/easy_install"
-    @resource.easy_install_binary.should eql("/opt/local/bin/easy_install")
+    expect(@resource.easy_install_binary).to eql("/opt/local/bin/easy_install")
   end
 end

data/spec/unit/resource/env_spec.rb

@@ -26,43 +26,43 @@ describe Chef::Resource::Env do
   end
 
   it "should create a new Chef::Resource::Env" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Env)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Env)
   end
 
   it "should have a name" do
-    @resource.name.should eql("FOO")
+    expect(@resource.name).to eql("FOO")
   end
 
   it "should have a default action of 'create'" do
-    @resource.action.should eql(:create)
+    expect(@resource.action).to eql(:create)
   end
 
   { :create => false, :delete => false, :modify => false, :flibber => true }.each do |action,bad_value|
     it "should #{bad_value ? 'not' : ''} accept #{action.to_s}" do
       if bad_value
-        lambda { @resource.action action }.should raise_error(ArgumentError)
+        expect { @resource.action action }.to raise_error(ArgumentError)
       else
-        lambda { @resource.action action }.should_not raise_error
+        expect { @resource.action action }.not_to raise_error
       end
     end
   end
 
   it "should use the object name as the key_name by default" do
-    @resource.key_name.should eql("FOO")
+    expect(@resource.key_name).to eql("FOO")
   end
 
   it "should accept a string as the env value via 'value'" do
-    lambda { @resource.value "bar" }.should_not raise_error
+    expect { @resource.value "bar" }.not_to raise_error
   end
 
   it "should not accept a Hash for the env value via 'to'" do
-    lambda { @resource.value Hash.new }.should raise_error(ArgumentError)
+    expect { @resource.value Hash.new }.to raise_error(ArgumentError)
   end
 
   it "should allow you to set an env value via 'to'" do
     @resource.value "bar"
-    @resource.value.should eql("bar")
+    expect(@resource.value).to eql("bar")
   end
 
   describe "when it has key name and value" do
@@ -74,11 +74,11 @@ describe Chef::Resource::Env do
 
     it "describes its state" do
       state = @resource.state
-      state[:value].should == "level7"
+      expect(state[:value]).to eq("level7")
     end
 
     it "returns the key name as its identity" do
-      @resource.identity.should == "charmander"
+      expect(@resource.identity).to eq("charmander")
     end
   end
 

data/spec/unit/resource/erl_call_spec.rb

@@ -26,45 +26,45 @@ describe Chef::Resource::ErlCall do
   end
 
   it "should create a new Chef::Resource::ErlCall" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::ErlCall)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::ErlCall)
   end
 
   it "should have a resource name of :erl_call" do
-    @resource.resource_name.should eql(:erl_call)
+    expect(@resource.resource_name).to eql(:erl_call)
   end
 
   it "should have a default action of run" do
-    @resource.action.should eql("run")
+    expect(@resource.action).to eql("run")
   end
 
   it "should accept run as an action" do
-    lambda { @resource.action :run }.should_not raise_error
+    expect { @resource.action :run }.not_to raise_error
   end
 
   it "should allow you to set the code attribute" do
     @resource.code "q()."
-    @resource.code.should eql("q().")
+    expect(@resource.code).to eql("q().")
   end
 
   it "should allow you to set the cookie attribute" do
     @resource.cookie "nomnomnom"
-    @resource.cookie.should eql("nomnomnom")
+    expect(@resource.cookie).to eql("nomnomnom")
   end
 
   it "should allow you to set the distributed attribute" do
     @resource.distributed true
-    @resource.distributed.should eql(true)
+    expect(@resource.distributed).to eql(true)
   end
 
   it "should allow you to set the name_type attribute" do
     @resource.name_type "sname"
-    @resource.name_type.should eql("sname")
+    expect(@resource.name_type).to eql("sname")
   end
 
   it "should allow you to set the node_name attribute" do
     @resource.node_name "chef@erlang"
-    @resource.node_name.should eql("chef@erlang")
+    expect(@resource.node_name).to eql("chef@erlang")
   end
 
   describe "when it has cookie and node_name" do
@@ -75,7 +75,7 @@ describe Chef::Resource::ErlCall do
     end
 
     it "returns the code as its identity" do
-      @resource.identity.should == "erl-call:function()"
+      expect(@resource.identity).to eq("erl-call:function()")
     end
   end
 end

data/spec/unit/resource/execute_spec.rb

@@ -23,4 +23,9 @@ describe Chef::Resource::Execute do
   let(:resource_instance_name) { "some command" }
   let(:execute_resource) { Chef::Resource::Execute.new(resource_instance_name) }
   it_behaves_like "an execute resource"
+
+  it "default guard interpreter should be :execute interpreter" do
+    expect(execute_resource.guard_interpreter).to be(:execute)
+  end
+
 end

data/spec/unit/resource/file_spec.rb

@@ -25,55 +25,55 @@ describe Chef::Resource::File do
   end
 
   it "should have a name" do
-    @resource.name.should eql("fakey_fakerton")
+    expect(@resource.name).to eql("fakey_fakerton")
   end
 
   it "should have a default action of 'create'" do
-    @resource.action.should eql("create")
+    expect(@resource.action).to eql("create")
   end
 
   it "should have a default content of nil" do
-    @resource.content.should be_nil
+    expect(@resource.content).to be_nil
   end
 
   it "should be set to back up 5 files by default" do
-    @resource.backup.should eql(5)
+    expect(@resource.backup).to eql(5)
   end
 
   it "should only accept strings for content" do
-    lambda { @resource.content 5 }.should raise_error(ArgumentError)
-    lambda { @resource.content :foo }.should raise_error(ArgumentError)
-    lambda { @resource.content "hello" => "there" }.should raise_error(ArgumentError)
-    lambda { @resource.content "hi" }.should_not raise_error
+    expect { @resource.content 5 }.to raise_error(ArgumentError)
+    expect { @resource.content :foo }.to raise_error(ArgumentError)
+    expect { @resource.content "hello" => "there" }.to raise_error(ArgumentError)
+    expect { @resource.content "hi" }.not_to raise_error
   end
 
   it "should only accept false or a number for backup" do
-    lambda { @resource.backup true }.should raise_error(ArgumentError)
-    lambda { @resource.backup false }.should_not raise_error
-    lambda { @resource.backup 10 }.should_not raise_error
-    lambda { @resource.backup "blues" }.should raise_error(ArgumentError)
+    expect { @resource.backup true }.to raise_error(ArgumentError)
+    expect { @resource.backup false }.not_to raise_error
+    expect { @resource.backup 10 }.not_to raise_error
+    expect { @resource.backup "blues" }.to raise_error(ArgumentError)
   end
 
   it "should accept a sha256 for checksum" do
-    lambda { @resource.checksum "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa" }.should_not raise_error
-    lambda { @resource.checksum "monkey!" }.should raise_error(ArgumentError)
+    expect { @resource.checksum "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa" }.not_to raise_error
+    expect { @resource.checksum "monkey!" }.to raise_error(ArgumentError)
   end
 
   it "should accept create, delete or touch for action" do
-    lambda { @resource.action :create }.should_not raise_error
-    lambda { @resource.action :delete }.should_not raise_error
-    lambda { @resource.action :touch }.should_not raise_error
-    lambda { @resource.action :blues }.should raise_error(ArgumentError)
+    expect { @resource.action :create }.not_to raise_error
+    expect { @resource.action :delete }.not_to raise_error
+    expect { @resource.action :touch }.not_to raise_error
+    expect { @resource.action :blues }.to raise_error(ArgumentError)
   end
 
   it "should use the object name as the path by default" do
-    @resource.path.should eql("fakey_fakerton")
+    expect(@resource.path).to eql("fakey_fakerton")
   end
 
   it "should accept a string as the path" do
-    lambda { @resource.path "/tmp" }.should_not raise_error
-    @resource.path.should eql("/tmp")
-    lambda { @resource.path Hash.new }.should raise_error(ArgumentError)
+    expect { @resource.path "/tmp" }.not_to raise_error
+    expect(@resource.path).to eql("/tmp")
+    expect { @resource.path Hash.new }.to raise_error(ArgumentError)
   end
 
   describe "when it has a path, owner, group, mode, and checksum" do
@@ -88,15 +88,15 @@ describe Chef::Resource::File do
     context "on unix", :unix_only do
       it "describes its state" do
         state = @resource.state
-        state[:owner].should == "root"
-        state[:group].should == "wheel"
-        state[:mode].should == "0644"
-        state[:checksum].should == "1" * 64
+        expect(state[:owner]).to eq("root")
+        expect(state[:group]).to eq("wheel")
+        expect(state[:mode]).to eq("0644")
+        expect(state[:checksum]).to eq("1" * 64)
       end
     end
 
     it "returns the file path as its identity" do
-      @resource.identity.should == "/tmp/foo.txt"
+      expect(@resource.identity).to eq("/tmp/foo.txt")
     end
 
   end
@@ -108,8 +108,8 @@ describe Chef::Resource::File do
     end
     it "describes its state including windows ACL attributes" do
       state = @resource.state
-      state[:rights].should == [ {:permissions => :read, :principals => "Everyone"},
-                               {:permissions => :full_control, :principals => "DOMAIN\User"} ]
+      expect(state[:rights]).to eq([ {:permissions => :read, :principals => "Everyone"},
+                               {:permissions => :full_control, :principals => "DOMAIN\User"} ])
     end
   end
 

data/spec/unit/resource/freebsd_package_spec.rb

@@ -32,15 +32,15 @@ describe Chef::Resource::FreebsdPackage do
 
   describe "Initialization" do
     it "should return a Chef::Resource::FreebsdPackage" do
-      @resource.should be_a_kind_of(Chef::Resource::FreebsdPackage)
+      expect(@resource).to be_a_kind_of(Chef::Resource::FreebsdPackage)
     end
 
     it "should set the resource_name to :freebsd_package" do
-      @resource.resource_name.should eql(:freebsd_package)
+      expect(@resource.resource_name).to eql(:freebsd_package)
     end
 
     it "should not set the provider" do
-      @resource.provider.should be_nil
+      expect(@resource.provider).to be_nil
     end
   end
 
@@ -50,16 +50,16 @@ describe Chef::Resource::FreebsdPackage do
       it "should be Freebsd::Port" do
         @resource.source('ports')
         @resource.after_created
-        @resource.provider.should == Chef::Provider::Package::Freebsd::Port
+        expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Port)
       end
     end
 
     describe "if __Freebsd_version is greater than or equal to 1000017" do
       it "should be Freebsd::Pkgng" do
         [1000017, 1000018, 1000500, 1001001, 1100000].each do |__freebsd_version|
-          @node.normal[:os_version] = __freebsd_version
+          @node.automatic_attrs[:os_version] = __freebsd_version
           @resource.after_created
-          @resource.provider.should == Chef::Provider::Package::Freebsd::Pkgng
+          expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkgng)
         end
       end
     end
@@ -67,22 +67,21 @@ describe Chef::Resource::FreebsdPackage do
     describe "if pkgng enabled" do
       it "should be Freebsd::Pkgng" do
         pkg_enabled = OpenStruct.new(:stdout => "yes\n")
-        @resource.stub(:shell_out!).with("make -V WITH_PKGNG", :env => nil).and_return(pkg_enabled)
+        allow(@resource).to receive(:shell_out!).with("make -V WITH_PKGNG", :env => nil).and_return(pkg_enabled)
         @resource.after_created
-        @resource.provider.should == Chef::Provider::Package::Freebsd::Pkgng
+        expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkgng)
       end
     end
 
     describe "if __Freebsd_version is less than 1000017 and pkgng not enabled" do
       it "should be Freebsd::Pkg" do
         pkg_enabled = OpenStruct.new(:stdout => "\n")
-        @resource.stub(:shell_out!).with("make -V WITH_PKGNG", :env => nil).and_return(pkg_enabled)
+        allow(@resource).to receive(:shell_out!).with("make -V WITH_PKGNG", :env => nil).and_return(pkg_enabled)
 
         [1000016, 1000000, 901503, 902506, 802511].each do |__freebsd_version|
-          @node[:os_version] == __freebsd_version
-          @node.normal[:os_version] = __freebsd_version
+          @node.automatic_attrs[:os_version] = __freebsd_version
           @resource.after_created
-          @resource.provider.should == Chef::Provider::Package::Freebsd::Pkg
+          expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkg)
         end
       end
     end

data/spec/unit/resource/gem_package_spec.rb

@@ -17,24 +17,17 @@
 #
 
 require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
 
 describe Chef::Resource::GemPackage, "initialize" do
 
-  before(:each) do
-    @resource = Chef::Resource::GemPackage.new("foo")
-  end
-
-  it "should return a Chef::Resource::GemPackage" do
-    @resource.should be_a_kind_of(Chef::Resource::GemPackage)
-  end
-
-  it "should set the resource_name to :gem_package" do
-    @resource.resource_name.should eql(:gem_package)
-  end
+  static_provider_resolution(
+    resource: Chef::Resource::GemPackage,
+    provider: Chef::Provider::Package::Rubygems,
+    name: :gem_package,
+    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::GemPackage, "gem_binary" do
@@ -44,6 +37,6 @@ describe Chef::Resource::GemPackage, "gem_binary" do
 
   it "should set the gem_binary variable to whatever is passed in" do
     @resource.gem_binary("/opt/local/bin/gem")
-    @resource.gem_binary.should eql("/opt/local/bin/gem")
+    expect(@resource.gem_binary).to eql("/opt/local/bin/gem")
   end
 end

data/spec/unit/resource/git_spec.rb

@@ -17,30 +17,34 @@
 #
 
 require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
 
 describe Chef::Resource::Git do
 
+  static_provider_resolution(
+    resource: Chef::Resource::Git,
+    provider: Chef::Provider::Git,
+    name: :git,
+    action: :sync,
+  )
+
   before(:each) do
     @git = Chef::Resource::Git.new("my awesome webapp")
   end
 
   it "is a kind of Scm Resource" do
-    @git.should be_a_kind_of(Chef::Resource::Scm)
-    @git.should be_an_instance_of(Chef::Resource::Git)
-  end
-
-  it "uses the git provider" do
-    @git.provider.should eql(Chef::Provider::Git)
+    expect(@git).to be_a_kind_of(Chef::Resource::Scm)
+    expect(@git).to be_an_instance_of(Chef::Resource::Git)
   end
 
   it "uses aliases revision as branch" do
     @git.branch "HEAD"
-    @git.revision.should eql("HEAD")
+    expect(@git.revision).to eql("HEAD")
   end
 
   it "aliases revision as reference" do
     @git.reference "v1.0 tag"
-    @git.revision.should eql("v1.0 tag")
+    expect(@git.revision).to eql("v1.0 tag")
   end
 
 end

data/spec/unit/resource/group_spec.rb

@@ -25,47 +25,47 @@ describe Chef::Resource::Group, "initialize" do
   end
 
   it "should create a new Chef::Resource::Group" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Group)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Group)
   end
 
   it "should set the resource_name to :group" do
-    @resource.resource_name.should eql(:group)
+    expect(@resource.resource_name).to eql(:group)
   end
 
   it "should set the group_name equal to the argument to initialize" do
-    @resource.group_name.should eql("admin")
+    expect(@resource.group_name).to eql("admin")
   end
 
   it "should default gid to nil" do
-    @resource.gid.should eql(nil)
+    expect(@resource.gid).to eql(nil)
   end
 
   it "should default members to an empty array" do
-    @resource.members.should eql([])
+    expect(@resource.members).to eql([])
   end
 
   it "should alias users to members, also an empty array" do
-    @resource.users.should eql([])
+    expect(@resource.users).to eql([])
   end
 
   it "should set action to :create" do
-    @resource.action.should eql(:create)
+    expect(@resource.action).to eql(:create)
   end
 
   %w{create remove modify manage}.each do |action|
     it "should allow action #{action}" do
-      @resource.allowed_actions.detect { |a| a == action.to_sym }.should eql(action.to_sym)
+      expect(@resource.allowed_actions.detect { |a| a == action.to_sym }).to eql(action.to_sym)
     end
   end
 
   it "should accept domain groups (@ or \ separator) on non-windows" do
-    lambda { @resource.group_name "domain\@group" }.should_not raise_error
-    @resource.group_name.should == "domain\@group"
-    lambda { @resource.group_name "domain\\group" }.should_not raise_error
-    @resource.group_name.should == "domain\\group"
-    lambda { @resource.group_name "domain\\group^name" }.should_not raise_error
-    @resource.group_name.should == "domain\\group^name"
+    expect { @resource.group_name "domain\@group" }.not_to raise_error
+    expect(@resource.group_name).to eq("domain\@group")
+    expect { @resource.group_name "domain\\group" }.not_to raise_error
+    expect(@resource.group_name).to eq("domain\\group")
+    expect { @resource.group_name "domain\\group^name" }.not_to raise_error
+    expect(@resource.group_name).to eq("domain\\group^name")
   end
 end
 
@@ -76,11 +76,11 @@ describe Chef::Resource::Group, "group_name" do
 
   it "should allow a string" do
     @resource.group_name "pirates"
-    @resource.group_name.should eql("pirates")
+    expect(@resource.group_name).to eql("pirates")
   end
 
   it "should not allow a hash" do
-    lambda { @resource.send(:group_name, { :aj => "is freakin awesome" }) }.should raise_error(ArgumentError)
+    expect { @resource.send(:group_name, { :aj => "is freakin awesome" }) }.to raise_error(ArgumentError)
   end
 end
 
@@ -91,11 +91,11 @@ describe Chef::Resource::Group, "gid" do
 
   it "should allow an integer" do
     @resource.gid 100
-    @resource.gid.should eql(100)
+    expect(@resource.gid).to eql(100)
   end
 
   it "should not allow a hash" do
-    lambda { @resource.send(:gid, { :aj => "is freakin awesome" }) }.should raise_error(ArgumentError)
+    expect { @resource.send(:gid, { :aj => "is freakin awesome" }) }.to raise_error(ArgumentError)
   end
 end
 
@@ -107,16 +107,16 @@ describe Chef::Resource::Group, "members" do
   [ :users, :members].each do |method|
     it "(#{method}) should allow and convert a string" do
       @resource.send(method, "aj")
-      @resource.send(method).should eql(["aj"])
+      expect(@resource.send(method)).to eql(["aj"])
     end
 
     it "(#{method}) should allow an array" do
       @resource.send(method, [ "aj", "adam" ])
-      @resource.send(method).should eql( ["aj", "adam"] )
+      expect(@resource.send(method)).to eql( ["aj", "adam"] )
     end
 
     it "(#{method}) should not allow a hash" do
-      lambda { @resource.send(method, { :aj => "is freakin awesome" }) }.should raise_error(ArgumentError)
+      expect { @resource.send(method, { :aj => "is freakin awesome" }) }.to raise_error(ArgumentError)
     end
   end
 end
@@ -127,16 +127,16 @@ describe Chef::Resource::Group, "append" do
   end
 
   it "should default to false" do
-    @resource.append.should eql(false)
+    expect(@resource.append).to eql(false)
   end
 
   it "should allow a boolean" do
     @resource.append true
-    @resource.append.should eql(true)
+    expect(@resource.append).to eql(true)
   end
 
   it "should not allow a hash" do
-    lambda { @resource.send(:gid, { :aj => "is freakin awesome" }) }.should raise_error(ArgumentError)
+    expect { @resource.send(:gid, { :aj => "is freakin awesome" }) }.to raise_error(ArgumentError)
   end
 
   describe "when it has members" do
@@ -147,11 +147,11 @@ describe Chef::Resource::Group, "append" do
 
     it "describes its state" do
       state = @resource.state
-      state[:members].should eql(["blastoise", "pikachu"])
+      expect(state[:members]).to eql(["blastoise", "pikachu"])
     end
 
     it "returns the group name as its identity" do
-      @resource.identity.should == "pokemon"
+      expect(@resource.identity).to eq("pokemon")
     end
   end
 end