chef 13.6.4 → 13.7.16

data/spec/unit/resource/msu_package_spec.rb

@@ -31,19 +31,25 @@ describe Chef::Resource::MsuPackage do
     expect(resource.resource_name).to eql(:msu_package)
   end
 
-  it "sets the source as it's name" do
-    expect(resource.source).to eql("test_pkg")
+  it "sets the default action as :install" do
+    expect(resource.action).to eql([:install])
   end
 
-  it "sets the default action as :install" do
-    expect(resource.action).to eql(:install)
+  it "coerces name property to package_name property" do
+    expect(resource.package_name).to eql("test_pkg")
   end
 
-  it "raises error if invalid action is given" do
-    expect { resource.action "abc" }.to raise_error(Chef::Exceptions::ValidationFailed)
+  it "coerces name property to a source property if source not provided" do
+    expect(resource.source).to end_with("test_pkg")
   end
 
-  it "coerce its name to a package_name" do
-    expect(resource.package_name).to eql("test_pkg")
+  it "coerces name property to a source property if source not provided and package_name is" do
+    resource.package_name("package.msu")
+    expect(resource.source).to end_with("package.msu")
+  end
+
+  it "coerces source property if it does not looks like a path" do
+    resource.source("package.msu")
+    expect(resource.source).not_to eq("package.msu")
   end
 end

data/spec/unit/resource/ohai_spec.rb

@@ -20,41 +20,39 @@ require "spec_helper"
 
 describe Chef::Resource::Ohai do
 
-  before(:each) do
-    @resource = Chef::Resource::Ohai.new("ohai_reload")
-  end
+  let(:resource) { Chef::Resource::Ohai.new("ohai_reload") }
 
-  it "should create a new Chef::Resource::Ohai" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Ohai)
+  it "creates a new Chef::Resource::Ohai" do
+    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
-    expect(@resource.resource_name).to eql(:ohai)
+  it "has a resource name of :ohai" do
+    expect(resource.resource_name).to eql(:ohai)
   end
 
-  it "should have a default action of reload" do
-    expect(@resource.action).to eql([:reload])
+  it "has a default action of reload" do
+    expect(resource.action).to eql([:reload])
   end
 
-  it "should allow you to set the plugin attribute" do
-    @resource.plugin "passwd"
-    expect(@resource.plugin).to eql("passwd")
+  it "allows you to set the plugin attribute" do
+    resource.plugin "passwd"
+    expect(resource.plugin).to eql("passwd")
   end
 
   describe "when it has a plugin value" do
     before do
-      @resource.name("test")
-      @resource.plugin("passwd")
+      resource.name("test")
+      resource.plugin("passwd")
     end
 
     it "describes its state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:plugin]).to eq("passwd")
     end
 
     it "returns the name as its identity" do
-      expect(@resource.identity).to eq("test")
+      expect(resource.identity).to eq("test")
     end
   end
 

data/spec/unit/resource/openbsd_package_spec.rb

@@ -32,15 +32,15 @@ describe Chef::Resource::OpenbsdPackage do
   end
 
   describe "Initialization" do
-    it "should return a Chef::Resource::OpenbsdPackage" do
+    it "returns a Chef::Resource::OpenbsdPackage" do
       expect(@resource).to be_a_kind_of(Chef::Resource::OpenbsdPackage)
     end
 
-    it "should set the resource_name to :openbsd_package" do
+    it "sets the resource_name to :openbsd_package" do
       expect(@resource.resource_name).to eql(:openbsd_package)
     end
 
-    it "should not set the provider" do
+    it "does not set the provider" do
       expect(@resource.provider).to be_nil
     end
   end

data/spec/unit/resource/osx_profile_spec.rb

@@ -25,36 +25,36 @@ describe Chef::Resource::OsxProfile do
     run_context)
   end
 
-  it "should create a new Chef::Resource::OsxProfile" do
+  it "creates a new Chef::Resource::OsxProfile" do
     expect(resource).to be_a_kind_of(Chef::Resource)
     expect(resource).to be_a_kind_of(Chef::Resource::OsxProfile)
   end
 
-  it "should have a resource name of profile" do
+  it "has a resource name of profile" do
     expect(resource.resource_name).to eql(:osx_profile)
   end
 
-  it "should have a default action of install" do
+  it "has a default action of install" do
     expect(resource.action).to eql([:install])
   end
 
-  it "should accept install and remove as actions" do
+  it "accepts install and remove as actions" do
     expect { resource.action :install }.not_to raise_error
     expect { resource.action :remove }.not_to raise_error
   end
 
-  it "should allow you to set the profile attribute" do
+  it "allows you to set the profile attribute" do
     resource.profile "com.testprofile.screensaver"
     expect(resource.profile).to eql("com.testprofile.screensaver")
   end
 
-  it "should allow you to set the profile attribute to a string" do
+  it "allows you to set the profile attribute to a string" do
     resource.profile "com.testprofile.screensaver"
     expect(resource.profile).to be_a(String)
     expect(resource.profile).to eql("com.testprofile.screensaver")
   end
 
-  it "should allow you to set the profile attribute to a hash" do
+  it "allows you to set the profile attribute to a hash" do
     test_profile = { "profile" => false }
     resource.profile test_profile
     expect(resource.profile).to be_a(Hash)

data/spec/unit/resource/package_spec.rb

@@ -20,84 +20,80 @@
 require "spec_helper"
 
 describe Chef::Resource::Package do
+  let(:resource) { Chef::Resource::Package.new("emacs") }
 
-  before(:each) do
-    @resource = Chef::Resource::Package.new("emacs")
+  it "creates a new Chef::Resource::Package" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::Package)
   end
 
-  it "should create a new Chef::Resource::Package" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Package)
+  it "sets the package_name to the first argument to new" do
+    expect(resource.package_name).to eql("emacs")
   end
 
-  it "should set the package_name to the first argument to new" do
-    expect(@resource.package_name).to eql("emacs")
+  it "accepts a string for the package name" do
+    resource.package_name "something"
+    expect(resource.package_name).to eql("something")
   end
 
-  it "should accept a string for the package name" do
-    @resource.package_name "something"
-    expect(@resource.package_name).to eql("something")
+  it "accepts a string for the version" do
+    resource.version "something"
+    expect(resource.version).to eql("something")
   end
 
-  it "should accept a string for the version" do
-    @resource.version "something"
-    expect(@resource.version).to eql("something")
+  it "accepts a string for the response file" do
+    resource.response_file "something"
+    expect(resource.response_file).to eql("something")
   end
 
-  it "should accept a string for the response file" do
-    @resource.response_file "something"
-    expect(@resource.response_file).to eql("something")
+  it "accepts a hash for response file template variables" do
+    resource.response_file_variables({ :variables => true })
+    expect(resource.response_file_variables).to eql({ :variables => true })
   end
 
-  it "should accept a hash for response file template variables" do
-    @resource.response_file_variables({ :variables => true })
-    expect(@resource.response_file_variables).to eql({ :variables => true })
+  it "accepts a string for the source" do
+    resource.source "something"
+    expect(resource.source).to eql("something")
   end
 
-  it "should accept a string for the source" do
-    @resource.source "something"
-    expect(@resource.source).to eql("something")
+  it "accepts a string for the options" do
+    resource.options "something"
+    expect(resource.options).to eql(["something"])
   end
 
-  it "should accept a string for the options" do
-    @resource.options "something"
-    expect(@resource.options).to eql(["something"])
-  end
-
-  it "should split options" do
-    @resource.options "-a -b 'arg with spaces' -b \"and quotes\""
-    expect(@resource.options).to eql(["-a", "-b", "arg with spaces", "-b", "and quotes"])
+  it "splits options" do
+    resource.options "-a -b 'arg with spaces' -b \"and quotes\""
+    expect(resource.options).to eql(["-a", "-b", "arg with spaces", "-b", "and quotes"])
   end
 
   describe "when it has a package_name and version" do
     before do
-      @resource.package_name("tomcat")
-      @resource.version("10.9.8")
-      @resource.options("-al")
+      resource.package_name("tomcat")
+      resource.version("10.9.8")
+      resource.options("-al")
     end
 
     it "describes its state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:version]).to eq("10.9.8")
       expect(state[:options]).to eq(["-al"])
     end
 
     it "returns the file path as its identity" do
-      expect(@resource.identity).to eq("tomcat")
+      expect(resource.identity).to eq("tomcat")
     end
 
     it "takes options as an array" do
-      @resource.options [ "-a", "-l" ]
-      expect(@resource.options).to eq(["-a", "-l" ])
+      resource.options [ "-a", "-l" ]
+      expect(resource.options).to eq(["-a", "-l" ])
     end
   end
 
   # String, Integer
   [ "600", 600 ].each do |val|
     it "supports setting a timeout as a #{val.class}" do
-      @resource.timeout(val)
-      expect(@resource.timeout).to eql(val)
+      resource.timeout(val)
+      expect(resource.timeout).to eql(val)
     end
   end
-
 end

data/spec/unit/resource/perl_spec.rb

@@ -20,21 +20,18 @@ require "spec_helper"
 
 describe Chef::Resource::Perl do
 
-  before(:each) do
-    @resource = Chef::Resource::Perl.new("fakey_fakerton")
-  end
+  let(:resource) { Chef::Resource::Perl.new("fakey_fakerton") }
 
-  it "should create a new Chef::Resource::Perl" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Perl)
+  it "creates a new Chef::Resource::Perl" do
+    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
-    expect(@resource.resource_name).to eql(:perl)
+  it "has a resource name of :perl" do
+    expect(resource.resource_name).to eql(:perl)
   end
 
-  it "should have an interpreter of perl" do
-    expect(@resource.interpreter).to eql("perl")
+  it "has an interpreter of perl" do
+    expect(resource.interpreter).to eql("perl")
   end
-
 end

data/spec/unit/resource/portage_package_spec.rb

@@ -16,23 +16,21 @@
 # limitations under the License.
 #
 
-require File.expand_path(File.join(File.dirname(__FILE__), "..", "..", "spec_helper"))
+require "spec_helper"
 
 describe Chef::Resource::PortagePackage, "initialize" do
 
-  before(:each) do
-    @resource = Chef::Resource::PortagePackage.new("foo")
-  end
+  let(:resource) { Chef::Resource::PortagePackage.new("foo") }
 
-  it "should return a Chef::Resource::PortagePackage" do
-    expect(@resource).to be_a_kind_of(Chef::Resource::PortagePackage)
+  it "returns a Chef::Resource::PortagePackage" do
+    expect(resource).to be_a_kind_of(Chef::Resource::PortagePackage)
   end
 
-  it "should set the resource_name to :portage_package" do
-    expect(@resource.resource_name).to eql(:portage_package)
+  it "sets the resource_name to :portage_package" do
+    expect(resource.resource_name).to eql(:portage_package)
   end
 
-  it "should set the provider to Chef::Provider::Package::Portage" do
-    expect(@resource.provider).to eql(Chef::Provider::Package::Portage)
+  it "sets the provider to Chef::Provider::Package::Portage" do
+    expect(resource.provider).to eql(Chef::Provider::Package::Portage)
   end
 end

data/spec/unit/resource/powershell_package_spec.rb

@@ -22,46 +22,46 @@ describe Chef::Resource::PowershellPackage do
 
   let(:resource) { Chef::Resource::PowershellPackage.new("test_package") }
 
-  it "should create a new Chef::Resource::PowershellPackage" do
+  it "creates a new Chef::Resource::PowershellPackage" do
     expect(resource).to be_a_kind_of(Chef::Resource)
     expect(resource).to be_a_kind_of(Chef::Resource::Package)
     expect(resource).to be_a_instance_of(Chef::Resource::PowershellPackage)
   end
 
   #to check the value of resource.resource_name
-  it "should have a resource name of :python" do
+  it "has a resource name of :python" do
     expect(resource.resource_name).to eql(:powershell_package)
   end
 
-  it "should coerce its name to a package_name array" do
+  it "coerces its name to a package_name array" do
     expect(resource.package_name).to eql(["test_package"])
   end
 
-  it "the package_name setter should coerce to arrays" do
+  it "the package_name setter coerces to arrays" do
     resource.package_name("git")
     expect(resource.package_name).to eql(["git"])
   end
 
-  it "the package_name setter should accept arrays" do
+  it "the package_name setter accepts arrays" do
     resource.package_name(%w{git unzip})
     expect(resource.package_name).to eql(%w{git unzip})
   end
 
-  it "the name should accept arrays" do
+  it "the name accepts arrays" do
     resource = Chef::Resource::PowershellPackage.new(%w{git unzip})
     expect(resource.package_name).to eql(%w{git unzip})
   end
 
-  it "the default version should be nil" do
+  it "the default version is nil" do
     expect(resource.version).to eql(nil)
   end
 
-  it "the version setter should coerce to arrays" do
+  it "the version setter coerces to arrays" do
     resource.version("1.2.3")
     expect(resource.version).to eql(["1.2.3"])
   end
 
-  it "the version setter should accept arrays" do
+  it "the version setter accepts arrays" do
     resource.version(["1.2.3", "4.5.6"])
     expect(resource.version).to eql(["1.2.3", "4.5.6"])
   end

data/spec/unit/resource/python_spec.rb

@@ -20,21 +20,18 @@ require "spec_helper"
 
 describe Chef::Resource::Python do
 
-  before(:each) do
-    @resource = Chef::Resource::Python.new("fakey_fakerton")
-  end
+  let(:resource) { Chef::Resource::Python.new("fakey_fakerton") }
 
-  it "should create a new Chef::Resource::Python" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Python)
+  it "creates a new Chef::Resource::Python" do
+    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
-    expect(@resource.resource_name).to eql(:python)
+  it "has a resource name of :python" do
+    expect(resource.resource_name).to eql(:python)
   end
 
-  it "should have an interpreter of python" do
-    expect(@resource.interpreter).to eql("python")
+  it "has an interpreter of python" do
+    expect(resource.interpreter).to eql("python")
   end
-
 end

data/spec/unit/resource/reboot_spec.rb

@@ -0,0 +1,50 @@
+#
+# Copyright:: Copyright 2017, Chef Software Inc.
+# License:: Apache License, Version 2.0
+#
+# 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"
+
+describe Chef::Resource::Reboot do
+
+  let(:resource) { Chef::Resource::Reboot.new("reboot me!") }
+
+  it "creates a new Chef::Resource::Reboot" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::Reboot)
+  end
+
+  it "has a default action of :nothing" do
+    expect(resource.action).to eql([:nothing])
+  end
+
+  it "supports the :nothing, :request_reboot, :reboot_now, and :cancel actions" do
+    expect(resource.allowed_actions).to include(:nothing, :request_reboot, :reboot_now, :cancel)
+  end
+
+  it "has a resource_name of :reboot" do
+    expect(resource.resource_name).to eq(:reboot)
+  end
+
+  it "accepts a String for the reboot reason" do
+    resource.reason "reasons"
+    expect(resource.reason).to eq("reasons")
+  end
+
+  it "accepts an Integer for delay_mins" do
+    resource.delay_mins 100
+    expect { resource.delay_mins "100" }.to raise_error(ArgumentError)
+  end
+end