chef 12.0.0.alpha.2 → 12.0.0.rc.0

data/spec/unit/resource/homebrew_package_spec.rb

@@ -0,0 +1,50 @@
+#
+# Author:: Joshua Timberman (<joshua@getchef.com>)
+# Copyright (c) 2014, Chef Software, Inc. <legal@getchef.com>
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
+
+describe Chef::Resource::HomebrewPackage, 'initialize' do
+
+  static_provider_resolution(
+    resource: Chef::Resource::HomebrewPackage,
+    provider: Chef::Provider::Package::Homebrew,
+    name: :homebrew_package,
+    action: :install,
+    os: "mac_os_x",
+  )
+
+  let(:resource) { Chef::Resource::HomebrewPackage.new('emacs') }
+
+  shared_examples 'home_brew user set and returned' do
+    it 'returns the configured homebrew_user' do
+      resource.homebrew_user user
+      expect(resource.homebrew_user).to eql(user)
+    end
+  end
+
+  context 'homebrew_user is set' do
+    let(:user) { 'Captain Picard' }
+    include_examples 'home_brew user set and returned'
+
+    context 'as an integer' do
+      let(:user) { 1001 }
+      include_examples 'home_brew user set and returned'
+    end
+  end
+
+end

data/spec/unit/resource/http_request_spec.rb

@@ -26,22 +26,22 @@ describe Chef::Resource::HttpRequest do
   end
 
   it "should create a new Chef::Resource::HttpRequest" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::HttpRequest)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::HttpRequest)
   end
 
   it "should set url to a string" do
     @resource.url "http://slashdot.org"
-    @resource.url.should eql("http://slashdot.org")
+    expect(@resource.url).to eql("http://slashdot.org")
   end
 
   it "should set the message to the name by default" do
-    @resource.message.should eql("fakey_fakerton")
+    expect(@resource.message).to eql("fakey_fakerton")
   end
 
   it "should set message to a string" do
     @resource.message "monkeybars"
-    @resource.message.should eql("monkeybars")
+    expect(@resource.message).to eql("monkeybars")
   end
 
   describe "when it has a message and headers" do
@@ -52,7 +52,7 @@ describe Chef::Resource::HttpRequest do
     end
 
     it "returns the url as its identity" do
-      @resource.identity.should == "http://www.trololol.net"
+      expect(@resource.identity).to eq("http://www.trololol.net")
     end
   end
 

data/spec/unit/resource/ifconfig_spec.rb

@@ -38,12 +38,12 @@ describe Chef::Resource::Ifconfig do
 
     it "describes its state" do
       state = @resource.state
-      state[:inet_addr].should == "434.2343.23"
-      state[:mask].should == "255.255.545"
+      expect(state[:inet_addr]).to eq("434.2343.23")
+      expect(state[:mask]).to eq("255.255.545")
     end
 
     it "returns the device as its identity" do
-      @resource.identity.should == "charmander"
+      expect(@resource.identity).to eq("charmander")
     end
   end
 
@@ -54,9 +54,9 @@ describe Chef::Resource::Ifconfig do
     end
 
     it "should use an ordinary Provider::Ifconfig as a provider for #{platform} #{version}" do
-      @resource.provider_for_action(:add).should be_a_kind_of(Chef::Provider::Ifconfig)
-      @resource.provider_for_action(:add).should_not be_a_kind_of(Chef::Provider::Ifconfig::Debian)
-      @resource.provider_for_action(:add).should_not be_a_kind_of(Chef::Provider::Ifconfig::Redhat)
+      expect(@resource.provider_for_action(:add)).to be_a_kind_of(Chef::Provider::Ifconfig)
+      expect(@resource.provider_for_action(:add)).not_to be_a_kind_of(Chef::Provider::Ifconfig::Debian)
+      expect(@resource.provider_for_action(:add)).not_to be_a_kind_of(Chef::Provider::Ifconfig::Redhat)
     end
   end
 
@@ -67,7 +67,7 @@ describe Chef::Resource::Ifconfig do
     end
 
     it "should use an Provider::Ifconfig::Redhat as a provider for #{platform} #{version}" do
-      @resource.provider_for_action(:add).should be_a_kind_of(Chef::Provider::Ifconfig::Redhat)
+      expect(@resource.provider_for_action(:add)).to be_a_kind_of(Chef::Provider::Ifconfig::Redhat)
     end
   end
 
@@ -78,7 +78,7 @@ describe Chef::Resource::Ifconfig do
     end
 
     it "should use an Ifconfig::Debian as a provider for #{platform} #{version}" do
-      @resource.provider_for_action(:add).should be_a_kind_of(Chef::Provider::Ifconfig::Debian)
+      expect(@resource.provider_for_action(:add)).to be_a_kind_of(Chef::Provider::Ifconfig::Debian)
     end
   end
 

data/spec/unit/resource/ips_package_spec.rb

@@ -17,27 +17,24 @@
 #
 
 require 'spec_helper'
+require 'support/shared/unit/resource/static_provider_resolution'
 
 describe Chef::Resource::IpsPackage, "initialize" do
 
+  static_provider_resolution(
+    resource: Chef::Resource::IpsPackage,
+    provider: Chef::Provider::Package::Ips,
+    name: :ips_package,
+    action: :install,
+    os: "solaris2",
+  )
+
   before(:each) do
     @resource = Chef::Resource::IpsPackage.new("crypto/gnupg")
   end
 
-  it "should return a Chef::Resource::IpsPackage" do
-    @resource.should be_a_kind_of(Chef::Resource::IpsPackage)
-  end
-
-  it "should set the resource_name to :ips_package" do
-    @resource.resource_name.should eql(:ips_package)
-  end
-
-  it "should set the provider to Chef::Provider::Package::Ips" do
-    @resource.provider.should eql(Chef::Provider::Package::Ips)
-  end
-
   it "should support accept_license" do
     @resource.accept_license(true)
-    @resource.accept_license.should eql(true)
+    expect(@resource.accept_license).to eql(true)
   end
 end

data/spec/unit/resource/link_spec.rb

@@ -22,78 +22,78 @@ require 'spec_helper'
 describe Chef::Resource::Link do
 
   before(:each) do
-    Chef::Resource::Link.any_instance.should_receive(:verify_links_supported!).and_return(true)
+    expect_any_instance_of(Chef::Resource::Link).to receive(:verify_links_supported!).and_return(true)
     @resource = Chef::Resource::Link.new("fakey_fakerton")
   end
 
   it "should create a new Chef::Resource::Link" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Link)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Link)
   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
 
   { :create => false, :delete => false, :blues => 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 target_file by default" do
-    @resource.target_file.should eql("fakey_fakerton")
+    expect(@resource.target_file).to eql("fakey_fakerton")
   end
 
   it "should accept a string as the link source via 'to'" do
-    lambda { @resource.to "/tmp" }.should_not raise_error
+    expect { @resource.to "/tmp" }.not_to raise_error
   end
 
   it "should not accept a Hash for the link source via 'to'" do
-    lambda { @resource.to Hash.new }.should raise_error(ArgumentError)
+    expect { @resource.to Hash.new }.to raise_error(ArgumentError)
   end
 
   it "should allow you to set a link source via 'to'" do
     @resource.to "/tmp/foo"
-    @resource.to.should eql("/tmp/foo")
+    expect(@resource.to).to eql("/tmp/foo")
   end
 
   it "should allow you to specify the link type" do
     @resource.link_type "symbolic"
-    @resource.link_type.should eql(:symbolic)
+    expect(@resource.link_type).to eql(:symbolic)
   end
 
   it "should default to a symbolic link" do
-    @resource.link_type.should eql(:symbolic)
+    expect(@resource.link_type).to eql(:symbolic)
   end
 
   it "should accept a hard link_type" do
     @resource.link_type :hard
-    @resource.link_type.should eql(:hard)
+    expect(@resource.link_type).to eql(:hard)
   end
 
   it "should reject any other link_type but :hard and :symbolic" do
-    lambda { @resource.link_type "x-men" }.should raise_error(ArgumentError)
+    expect { @resource.link_type "x-men" }.to raise_error(ArgumentError)
   end
 
   it "should accept a group name or id for group" do
-    lambda { @resource.group "root" }.should_not raise_error
-    lambda { @resource.group 123 }.should_not raise_error
-    lambda { @resource.group "root:goo" }.should raise_error(ArgumentError)
+    expect { @resource.group "root" }.not_to raise_error
+    expect { @resource.group 123 }.not_to raise_error
+    expect { @resource.group "root:goo" }.to raise_error(ArgumentError)
   end
 
   it "should accept a user name or id for owner" do
-    lambda { @resource.owner "root" }.should_not raise_error
-    lambda { @resource.owner 123 }.should_not raise_error
-    lambda { @resource.owner "root:goo" }.should raise_error(ArgumentError)
+    expect { @resource.owner "root" }.not_to raise_error
+    expect { @resource.owner 123 }.not_to raise_error
+    expect { @resource.owner "root:goo" }.to raise_error(ArgumentError)
   end
 
   describe "when it has to, link_type, owner, and group" do
@@ -107,13 +107,13 @@ describe Chef::Resource::Link do
 
     it "describes its state" do
       state = @resource.state
-      state[:to].should == "/to/dir/file.tar"
-      state[:owner].should == "root"
-      state[:group].should == "0664"
+      expect(state[:to]).to eq("/to/dir/file.tar")
+      expect(state[:owner]).to eq("root")
+      expect(state[:group]).to eq("0664")
     end
 
     it "returns the target file as its identity" do
-      @resource.identity.should == "/var/target.tar"
+      expect(@resource.identity).to eq("/var/target.tar")
     end
   end
 end

data/spec/unit/resource/log_spec.rb

@@ -27,29 +27,29 @@ describe Chef::Resource::Log do
   end
 
   it "should create a new Chef::Resource::Log" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Log)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Log)
   end
 
   it "supports the :write actions" do
-    @resource.allowed_actions.should include(:write)
+    expect(@resource.allowed_actions).to include(:write)
   end
 
   it "should have a name of log" do
-    @resource.resource_name.should == :log
+    expect(@resource.resource_name).to eq(:log)
   end
 
   it "should allow you to set a log string" do
-    @resource.name.should == @log_str
+    expect(@resource.name).to eq(@log_str)
   end
 
   it "should set the message to the first argument to new" do
-    @resource.message.should == @log_str
+    expect(@resource.message).to eq(@log_str)
   end
 
   it "should accept a string for the log message" do
     @resource.message "this is different"
-    @resource.message.should == "this is different"
+    expect(@resource.message).to eq("this is different")
   end
 
   it "should accept a vaild level option" do
@@ -58,7 +58,7 @@ describe Chef::Resource::Log do
     @resource.level :warn
     @resource.level :error
     @resource.level :fatal
-    lambda { @resource.level :unsupported }.should raise_error(ArgumentError)
+    expect { @resource.level :unsupported }.to raise_error(ArgumentError)
   end
 
   describe "when the identity is defined" do
@@ -67,7 +67,7 @@ describe Chef::Resource::Log do
     end
 
     it "returns the log string as its identity" do
-      @resource.identity.should == "ery day I'm loggin-in"
+      expect(@resource.identity).to eq("ery day I'm loggin-in")
     end
   end
 end

data/spec/unit/resource/macports_package_spec.rb

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

data/spec/unit/resource/mdadm_spec.rb

@@ -26,57 +26,57 @@ describe Chef::Resource::Mdadm do
   end
 
   it "should create a new Chef::Resource::Mdadm" do
-    @resource.should be_a_kind_of(Chef::Resource)
-    @resource.should be_a_kind_of(Chef::Resource::Mdadm)
+    expect(@resource).to be_a_kind_of(Chef::Resource)
+    expect(@resource).to be_a_kind_of(Chef::Resource::Mdadm)
   end
 
   it "should have a resource name of :mdadm" do
-    @resource.resource_name.should eql(:mdadm)
+    expect(@resource.resource_name).to eql(:mdadm)
   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, assemble, stop as actions" do
-    lambda { @resource.action :create }.should_not raise_error
-    lambda { @resource.action :assemble }.should_not raise_error
-    lambda { @resource.action :stop }.should_not raise_error
+    expect { @resource.action :create }.not_to raise_error
+    expect { @resource.action :assemble }.not_to raise_error
+    expect { @resource.action :stop }.not_to raise_error
   end
 
   it "should allow you to set the raid_device attribute" do
     @resource.raid_device "/dev/md3"
-    @resource.raid_device.should eql("/dev/md3")
+    expect(@resource.raid_device).to eql("/dev/md3")
   end
 
   it "should allow you to set the chunk attribute" do
     @resource.chunk 256
-    @resource.chunk.should eql(256)
+    expect(@resource.chunk).to eql(256)
   end
 
   it "should allow you to set the level attribute" do
     @resource.level 1
-    @resource.level.should eql(1)
+    expect(@resource.level).to eql(1)
   end
 
   it "should allow you to set the metadata attribute" do
     @resource.metadata "1.2"
-    @resource.metadata.should eql("1.2")
+    expect(@resource.metadata).to eql("1.2")
   end
 
   it "should allow you to set the bitmap attribute" do
     @resource.metadata "internal"
-    @resource.metadata.should eql("internal")
+    expect(@resource.metadata).to eql("internal")
   end
 
   it "should allow you to set the devices attribute" do
     @resource.devices ["/dev/sda", "/dev/sdb"]
-    @resource.devices.should eql(["/dev/sda", "/dev/sdb"])
+    expect(@resource.devices).to eql(["/dev/sda", "/dev/sdb"])
   end
 
   it "should allow you to set the exists attribute" do
     @resource.exists true
-    @resource.exists.should eql(true)
+    expect(@resource.exists).to eql(true)
   end
 
   describe "when it has devices, level, and chunk" do
@@ -89,13 +89,13 @@ describe Chef::Resource::Mdadm do
 
     it "describes its state" do
       state = @resource.state
-      state[:devices].should eql(["device1", "device2"])
-      state[:level].should == 1
-      state[:chunk].should == 42
+      expect(state[:devices]).to eql(["device1", "device2"])
+      expect(state[:level]).to eq(1)
+      expect(state[:chunk]).to eq(42)
     end
 
     it "returns the raid device as its identity" do
-      @resource.identity.should == "raider"
+      expect(@resource.identity).to eq("raider")
     end
   end