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

data/spec/unit/resource/route_spec.rb

@@ -26,64 +26,64 @@ describe Chef::Resource::Route do
   end
 
   it "should create a new Chef::Resource::Route" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Route)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Route)
   end
 
   it "should have a name" do
-    @resource.name.should eql("10.0.0.10")
+    expect(@resource.name).to eql("10.0.0.10")
   end
 
   it "should have a default action of 'add'" do
-    @resource.action.should eql([:add])
+    expect(@resource.action).to eql([:add])
   end
 
   it "should accept add or delete for action" do
-    lambda { @resource.action :add }.should_not raise_error
-    lambda { @resource.action :delete }.should_not raise_error
-    lambda { @resource.action :lolcat }.should raise_error(ArgumentError)
+    expect { @resource.action :add }.not_to raise_error
+    expect { @resource.action :delete }.not_to raise_error
+    expect { @resource.action :lolcat }.to raise_error(ArgumentError)
   end
 
   it "should use the object name as the target by default" do
-    @resource.target.should eql("10.0.0.10")
+    expect(@resource.target).to eql("10.0.0.10")
   end
 
   it "should allow you to specify the netmask" do
     @resource.netmask "255.255.255.0"
-    @resource.netmask.should eql("255.255.255.0")
+    expect(@resource.netmask).to eql("255.255.255.0")
   end
 
   it "should allow you to specify the gateway" do
     @resource.gateway "10.0.0.1"
-    @resource.gateway.should eql("10.0.0.1")
+    expect(@resource.gateway).to eql("10.0.0.1")
   end
 
   it "should allow you to specify the metric" do
     @resource.metric 10
-    @resource.metric.should eql(10)
+    expect(@resource.metric).to eql(10)
   end
 
   it "should allow you to specify the device" do
     @resource.device "eth0"
-    @resource.device.should eql("eth0")
+    expect(@resource.device).to eql("eth0")
   end
 
   it "should allow you to specify the route type" do
     @resource.route_type "host"
-    @resource.route_type.should eql(:host)
+    expect(@resource.route_type).to eql(:host)
   end
 
   it "should default to a host route type" do
-    @resource.route_type.should eql(:host)
+    expect(@resource.route_type).to eql(:host)
   end
 
   it "should accept a net route type" do
     @resource.route_type :net
-    @resource.route_type.should eql(:net)
+    expect(@resource.route_type).to eql(:net)
   end
 
   it "should reject any other route_type but :host and :net" do
-    lambda { @resource.route_type "lolcat" }.should raise_error(ArgumentError)
+    expect { @resource.route_type "lolcat" }.to raise_error(ArgumentError)
   end
 
   describe "when it has netmask, gateway, and device" do
@@ -96,12 +96,12 @@ describe Chef::Resource::Route do
 
     it "describes its state" do
       state = @resource.state
-      state[:netmask].should == "lemask"
-      state[:gateway].should == "111.111.111"
+      expect(state[:netmask]).to eq("lemask")
+      expect(state[:gateway]).to eq("111.111.111")
     end
 
     it "returns the target  as its identity" do
-      @resource.identity.should == "charmander"
+      expect(@resource.identity).to eq("charmander")
     end
   end
 end

data/spec/unit/resource/rpm_package_spec.rb

@@ -17,22 +17,18 @@
 #
 
 require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
 
 describe Chef::Resource::RpmPackage, "initialize" do
 
-  before(:each) do
-    @resource = Chef::Resource::RpmPackage.new("foo")
+  %w{linux aix}.each do |os|
+    static_provider_resolution(
+      resource: Chef::Resource::RpmPackage,
+      provider: Chef::Provider::Package::Rpm,
+      name: :rpm_package,
+      action: :install,
+      os: os
+    )
   end
 
-  it "should return a Chef::Resource::RpmPackage" do
-    @resource.should be_a_kind_of(Chef::Resource::RpmPackage)
-  end
-
-  it "should set the resource_name to :rpm_package" do
-    @resource.resource_name.should eql(:rpm_package)
-  end
-
-  it "should set the provider to Chef::Provider::Package::Rpm" do
-    @resource.provider.should eql(Chef::Provider::Package::Rpm)
-  end
 end

data/spec/unit/resource/ruby_block_spec.rb

@@ -26,27 +26,27 @@ describe Chef::Resource::RubyBlock do
   end
 
   it "should create a new Chef::Resource::RubyBlock" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::RubyBlock)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::RubyBlock)
   end
 
   it "should have a default action of 'create'" do
-    @resource.action.should eql("run")
+    expect(@resource.action).to eql("run")
   end
 
   it "should have a resource name of :ruby_block" do
-    @resource.resource_name.should eql(:ruby_block)
+    expect(@resource.resource_name).to eql(:ruby_block)
   end
 
   it "should accept a ruby block/proc/.. for the 'block' parameter" do
-    @resource.block do
+    expect(@resource.block do
       "foo"
-    end.call.should eql("foo")
+    end.call).to eql("foo")
   end
 
   it "allows the action to be 'create'" do
     @resource.action :create
-    @resource.action.should == [:create]
+    expect(@resource.action).to eq([:create])
   end
 
   describe "when it has been initialized with block code" do
@@ -55,7 +55,7 @@ describe Chef::Resource::RubyBlock do
     end
 
     it "returns the block as its identity" do
-      @resource.identity.should == "puts 'harrrr'"
+      expect(@resource.identity).to eq("puts 'harrrr'")
     end
   end
 end

data/spec/unit/resource/ruby_spec.rb

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

data/spec/unit/resource/scm_spec.rb

@@ -26,141 +26,141 @@ describe Chef::Resource::Scm do
   end
 
   it "should be a SCM resource" do
-    @resource.should be_a_kind_of(Chef::Resource::Scm)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Scm)
   end
 
   it "supports :checkout, :export, :sync, :diff, and :log actions" do
-    @resource.allowed_actions.should include(:checkout)
-    @resource.allowed_actions.should include(:export)
-    @resource.allowed_actions.should include(:sync)
-    @resource.allowed_actions.should include(:diff)
-    @resource.allowed_actions.should include(:log)
+    expect(@resource.allowed_actions).to include(:checkout)
+    expect(@resource.allowed_actions).to include(:export)
+    expect(@resource.allowed_actions).to include(:sync)
+    expect(@resource.allowed_actions).to include(:diff)
+    expect(@resource.allowed_actions).to include(:log)
   end
 
   it "takes the destination path as a string" do
     @resource.destination "/path/to/deploy/dir"
-    @resource.destination.should eql("/path/to/deploy/dir")
+    expect(@resource.destination).to eql("/path/to/deploy/dir")
   end
 
   it "takes a string for the repository URL" do
     @resource.repository "git://github.com/opscode/chef.git"
-    @resource.repository.should eql("git://github.com/opscode/chef.git")
+    expect(@resource.repository).to eql("git://github.com/opscode/chef.git")
   end
 
   it "takes a string for the revision" do
     @resource.revision "abcdef"
-    @resource.revision.should eql("abcdef")
+    expect(@resource.revision).to eql("abcdef")
   end
 
   it "defaults to the ``HEAD'' revision" do
-    @resource.revision.should eql("HEAD")
+    expect(@resource.revision).to eql("HEAD")
   end
 
   it "takes a string for the user to run as" do
     @resource.user "dr_deploy"
-    @resource.user.should eql("dr_deploy")
+    expect(@resource.user).to eql("dr_deploy")
   end
 
   it "also takes an integer for the user to run as" do
     @resource.user 0
-    @resource.user.should eql(0)
+    expect(@resource.user).to eql(0)
   end
 
   it "takes a string for the group to run as, defaulting to nil" do
-    @resource.group.should be_nil
+    expect(@resource.group).to be_nil
     @resource.group "opsdevs"
-    @resource.group.should == "opsdevs"
+    expect(@resource.group).to eq("opsdevs")
   end
 
   it "also takes an integer for the group to run as" do
     @resource.group 23
-    @resource.group.should == 23
+    expect(@resource.group).to eq(23)
   end
 
   it "has a svn_username String attribute" do
     @resource.svn_username "moartestsplz"
-    @resource.svn_username.should eql("moartestsplz")
+    expect(@resource.svn_username).to eql("moartestsplz")
   end
 
   it "has a svn_password String attribute" do
     @resource.svn_password "taftplz"
-    @resource.svn_password.should eql("taftplz")
+    expect(@resource.svn_password).to eql("taftplz")
   end
 
   it "has a svn_arguments String attribute" do
     @resource.svn_arguments "--more-taft plz"
-    @resource.svn_arguments.should eql("--more-taft plz")
+    expect(@resource.svn_arguments).to eql("--more-taft plz")
   end
 
   it "has a svn_info_args String attribute" do
-    @resource.svn_info_args.should be_nil
+    expect(@resource.svn_info_args).to be_nil
     @resource.svn_info_args("--no-moar-plaintext-creds yep")
-    @resource.svn_info_args.should == "--no-moar-plaintext-creds yep"
+    expect(@resource.svn_info_args).to eq("--no-moar-plaintext-creds yep")
   end
 
   it "takes the depth as an integer for shallow clones" do
     @resource.depth 5
-    @resource.depth.should == 5
-    lambda {@resource.depth "five"}.should raise_error(ArgumentError)
+    expect(@resource.depth).to eq(5)
+    expect {@resource.depth "five"}.to raise_error(ArgumentError)
   end
 
   it "defaults to nil depth for a full clone" do
-    @resource.depth.should be_nil
+    expect(@resource.depth).to be_nil
   end
 
   it "takes a boolean for #enable_submodules" do
     @resource.enable_submodules true
-    @resource.enable_submodules.should be_true
-    lambda {@resource.enable_submodules "lolz"}.should raise_error(ArgumentError)
+    expect(@resource.enable_submodules).to be_true
+    expect {@resource.enable_submodules "lolz"}.to raise_error(ArgumentError)
   end
 
   it "defaults to not enabling submodules" do
-    @resource.enable_submodules.should be_false
+    expect(@resource.enable_submodules).to be_false
   end
 
   it "takes a boolean for #enable_checkout" do
     @resource.enable_checkout true
-    @resource.enable_checkout.should be_true
-    lambda {@resource.enable_checkout "lolz"}.should raise_error(ArgumentError)
+    expect(@resource.enable_checkout).to be_true
+    expect {@resource.enable_checkout "lolz"}.to raise_error(ArgumentError)
   end
 
   it "defaults to enabling checkout" do
-    @resource.enable_checkout.should be_true
+    expect(@resource.enable_checkout).to be_true
   end
 
   it "takes a string for the remote" do
     @resource.remote "opscode"
-    @resource.remote.should eql("opscode")
-    lambda {@resource.remote 1337}.should raise_error(ArgumentError)
+    expect(@resource.remote).to eql("opscode")
+    expect {@resource.remote 1337}.to raise_error(ArgumentError)
   end
 
   it "defaults to ``origin'' for the remote" do
-    @resource.remote.should == "origin"
+    expect(@resource.remote).to eq("origin")
   end
 
   it "takes a string for the ssh wrapper" do
     @resource.ssh_wrapper "with_ssh_fu"
-    @resource.ssh_wrapper.should eql("with_ssh_fu")
+    expect(@resource.ssh_wrapper).to eql("with_ssh_fu")
   end
 
   it "defaults to nil for the ssh wrapper" do
-    @resource.ssh_wrapper.should be_nil
+    expect(@resource.ssh_wrapper).to be_nil
   end
 
   it "defaults to nil for the environment" do
-    @resource.environment.should be_nil
+    expect(@resource.environment).to be_nil
   end
 
   describe "when it has a timeout attribute" do
     let(:ten_seconds) { 10 }
     before { @resource.timeout(ten_seconds) }
     it "stores this timeout" do
-      @resource.timeout.should == ten_seconds
+      expect(@resource.timeout).to eq(ten_seconds)
     end
   end
   describe "when it has no timeout attribute" do
     it "should have no default timeout" do
-      @resource.timeout.should be_nil
+      expect(@resource.timeout).to be_nil
     end
   end
 
@@ -175,11 +175,11 @@ describe Chef::Resource::Scm do
 
     it "describes its state" do
       state = @resource.state
-      state[:revision].should == "1.2.3"
+      expect(state[:revision]).to eq("1.2.3")
     end
 
     it "returns the destination as its identity" do
-      @resource.identity.should == "hell"
+      expect(@resource.identity).to eq("hell")
     end
   end
 
@@ -187,7 +187,7 @@ describe Chef::Resource::Scm do
     let(:test_environment) { {'CHEF_ENV' => '/tmp' } }
     before { @resource.environment(test_environment) }
     it "stores this environment" do
-      @resource.environment.should == test_environment
+      expect(@resource.environment).to eq(test_environment)
     end
   end
 end

data/spec/unit/resource/script_spec.rb

@@ -26,7 +26,7 @@ describe Chef::Resource::Script do
 
   it "should accept a string for the interpreter" do
     script_resource.interpreter "naaaaNaNaNaaNaaNaaNaa"
-    script_resource.interpreter.should eql("naaaaNaNaNaaNaaNaaNaa")
+    expect(script_resource.interpreter).to eql("naaaaNaNaNaaNaaNaaNaa")
   end
 
   describe "when it has interpreter and flags" do
@@ -37,7 +37,7 @@ describe Chef::Resource::Script do
     end
 
    it "returns the command as its identity" do
-      script_resource.identity.should == "grep"
+      expect(script_resource.identity).to eq("grep")
     end
   end
 

data/spec/unit/resource/service_spec.rb

@@ -26,145 +26,135 @@ describe Chef::Resource::Service do
   end
 
   it "should create a new Chef::Resource::Service" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Service)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Service)
   end
-  
+
   it "should not set a provider unless node[:init_package] is defined as systemd" do
-    @resource.provider.should == nil
-  end
-    
-  it "should set the provider to Chef::Provider::Service::Systemd if node[:init_package] is systemd" do
-    node = Chef::Node.new
-    node.set[:init_package] = "systemd"
-    cookbook_collection = Chef::CookbookCollection.new([])
-    events = Chef::EventDispatch::Dispatcher.new
-    run_context = Chef::RunContext.new(node, cookbook_collection, events)
-    @resource = Chef::Resource::Service.new("chef", run_context)
-    @resource.provider.should == Chef::Provider::Service::Systemd
+    expect(@resource.provider).to eq(nil)
   end
 
   it "should set the service_name to the first argument to new" do
-    @resource.service_name.should eql("chef")
+    expect(@resource.service_name).to eql("chef")
   end
 
   it "should set the pattern to be the service name by default" do
-    @resource.pattern.should eql("chef")
+    expect(@resource.pattern).to eql("chef")
   end
 
   it "should accept a string for the service name" do
     @resource.service_name "something"
-    @resource.service_name.should eql("something")
+    expect(@resource.service_name).to eql("something")
   end
 
   it "should accept a string for the service pattern" do
     @resource.pattern ".*"
-    @resource.pattern.should eql(".*")
+    expect(@resource.pattern).to eql(".*")
   end
 
   it "should not accept a regexp for the service pattern" do
-    lambda {
+    expect {
       @resource.pattern /.*/
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service start command" do
     @resource.start_command "/etc/init.d/chef start"
-    @resource.start_command.should eql("/etc/init.d/chef start")
+    expect(@resource.start_command).to eql("/etc/init.d/chef start")
   end
 
   it "should not accept a regexp for the service start command" do
-    lambda {
+    expect {
       @resource.start_command /.*/
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service stop command" do
     @resource.stop_command "/etc/init.d/chef stop"
-    @resource.stop_command.should eql("/etc/init.d/chef stop")
+    expect(@resource.stop_command).to eql("/etc/init.d/chef stop")
   end
 
   it "should not accept a regexp for the service stop command" do
-    lambda {
+    expect {
       @resource.stop_command /.*/
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service status command" do
     @resource.status_command "/etc/init.d/chef status"
-    @resource.status_command.should eql("/etc/init.d/chef status")
+    expect(@resource.status_command).to eql("/etc/init.d/chef status")
   end
 
   it "should not accept a regexp for the service status command" do
-    lambda {
+    expect {
       @resource.status_command /.*/
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service restart command" do
     @resource.restart_command "/etc/init.d/chef restart"
-    @resource.restart_command.should eql("/etc/init.d/chef restart")
+    expect(@resource.restart_command).to eql("/etc/init.d/chef restart")
   end
 
   it "should not accept a regexp for the service restart command" do
-    lambda {
+    expect {
       @resource.restart_command /.*/
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service reload command" do
     @resource.reload_command "/etc/init.d/chef reload"
-    @resource.reload_command.should eql("/etc/init.d/chef reload")
+    expect(@resource.reload_command).to eql("/etc/init.d/chef reload")
   end
 
   it "should not accept a regexp for the service reload command" do
-    lambda {
+    expect {
       @resource.reload_command /.*/
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   it "should accept a string for the service init command" do
     @resource.init_command "/etc/init.d/chef"
-    @resource.init_command.should eql("/etc/init.d/chef")
+    expect(@resource.init_command).to eql("/etc/init.d/chef")
   end
 
   it "should not accept a regexp for the service init command" do
-    lambda {
+    expect {
       @resource.init_command /.*/
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
   %w{enabled running}.each do |attrib|
     it "should accept true for #{attrib}" do
       @resource.send(attrib, true)
-      @resource.send(attrib).should eql(true)
+      expect(@resource.send(attrib)).to eql(true)
     end
 
     it "should accept false for #{attrib}" do
       @resource.send(attrib, false)
-      @resource.send(attrib).should eql(false)
+      expect(@resource.send(attrib)).to eql(false)
     end
 
     it "should not accept a string for #{attrib}" do
-      lambda { @resource.send(attrib, "poop") }.should raise_error(ArgumentError)
+      expect { @resource.send(attrib, "poop") }.to raise_error(ArgumentError)
     end
 
     it "should default all the feature support to false" do
       support_hash = { :status => false, :restart => false, :reload=> false }
-      @resource.supports.should == support_hash
+      expect(@resource.supports).to eq(support_hash)
     end
 
     it "should allow you to set what features this resource supports as a array" do
       support_array = [ :status, :restart ]
       support_hash = { :status => true, :restart => true, :reload => false }
       @resource.supports(support_array)
-      @resource.supports.should == support_hash
+      expect(@resource.supports).to eq(support_hash)
     end
 
     it "should allow you to set what features this resource supports as a hash" do
       support_hash = { :status => true, :restart => true, :reload => false }
       @resource.supports(support_hash)
-      @resource.supports.should == support_hash
+      expect(@resource.supports).to eq(support_hash)
     end
   end
 
@@ -177,12 +167,12 @@ describe Chef::Resource::Service do
 
     it "describes its state" do
       state = @resource.state
-      state[:enabled].should eql(true)
-      state[:running].should eql(false)
+      expect(state[:enabled]).to eql(true)
+      expect(state[:running]).to eql(false)
     end
 
     it "returns the service name as its identity" do
-      @resource.identity.should == "superfriend"
+      expect(@resource.identity).to eq("superfriend")
     end
   end