chef 13.6.4 → 13.7.16

data/spec/unit/resource/script_spec.rb

@@ -24,7 +24,7 @@ describe Chef::Resource::Script do
   let(:script_resource) { Chef::Resource::Script.new(resource_instance_name) }
   let(:resource_name) { :script }
 
-  it "should accept a string for the interpreter" do
+  it "accepts a string for the interpreter" do
     script_resource.interpreter "naaaaNaNaNaaNaaNaaNaa"
     expect(script_resource.interpreter).to eql("naaaaNaNaNaaNaaNaaNaa")
   end

data/spec/unit/resource/service_spec.rb

@@ -20,180 +20,177 @@
 require "spec_helper"
 
 describe Chef::Resource::Service do
+  let(:resource) { Chef::Resource::Service.new("chef") }
 
-  before(:each) do
-    @resource = Chef::Resource::Service.new("chef")
+  it "creates a new Chef::Resource::Service" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::Service)
   end
 
-  it "should create a new Chef::Resource::Service" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Service)
+  it "does not set a provider unless node[:init_package] is defined as systemd" do
+    expect(resource.provider).to eq(nil)
   end
 
-  it "should not set a provider unless node[:init_package] is defined as systemd" do
-    expect(@resource.provider).to eq(nil)
+  it "sets the service_name to the first argument to new" do
+    expect(resource.service_name).to eql("chef")
   end
 
-  it "should set the service_name to the first argument to new" do
-    expect(@resource.service_name).to eql("chef")
+  it "sets the pattern to be the service name by default" do
+    expect(resource.pattern).to eql("chef")
   end
 
-  it "should set the pattern to be the service name by default" do
-    expect(@resource.pattern).to eql("chef")
+  it "accepts a string for the service name" do
+    resource.service_name "something"
+    expect(resource.service_name).to eql("something")
   end
 
-  it "should accept a string for the service name" do
-    @resource.service_name "something"
-    expect(@resource.service_name).to eql("something")
+  it "accepts a string for the service pattern" do
+    resource.pattern ".*"
+    expect(resource.pattern).to eql(".*")
   end
 
-  it "should accept a string for the service pattern" do
-    @resource.pattern ".*"
-    expect(@resource.pattern).to eql(".*")
-  end
-
-  it "should not accept a regexp for the service pattern" do
+  it "does not accept a regexp for the service pattern" do
     expect do
-      @resource.pattern /.*/
+      resource.pattern /.*/
     end.to raise_error(ArgumentError)
   end
 
-  it "should accept a string for the service start command" do
-    @resource.start_command "/etc/init.d/chef start"
-    expect(@resource.start_command).to eql("/etc/init.d/chef start")
+  it "accepts a string for the service start command" do
+    resource.start_command "/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
+  it "does not accept a regexp for the service start command" do
     expect do
-      @resource.start_command /.*/
+      resource.start_command /.*/
     end.to raise_error(ArgumentError)
   end
 
-  it "should accept a string for the service stop command" do
-    @resource.stop_command "/etc/init.d/chef stop"
-    expect(@resource.stop_command).to eql("/etc/init.d/chef stop")
+  it "accepts a string for the service stop command" do
+    resource.stop_command "/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
+  it "does not accept a regexp for the service stop command" do
     expect do
-      @resource.stop_command /.*/
+      resource.stop_command /.*/
     end.to raise_error(ArgumentError)
   end
 
-  it "should accept a string for the service status command" do
-    @resource.status_command "/etc/init.d/chef status"
-    expect(@resource.status_command).to eql("/etc/init.d/chef status")
+  it "accepts a string for the service status command" do
+    resource.status_command "/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
+  it "does not accept a regexp for the service status command" do
     expect do
-      @resource.status_command /.*/
+      resource.status_command /.*/
     end.to raise_error(ArgumentError)
   end
 
-  it "should accept a string for the service restart command" do
-    @resource.restart_command "/etc/init.d/chef restart"
-    expect(@resource.restart_command).to eql("/etc/init.d/chef restart")
+  it "accepts a string for the service restart command" do
+    resource.restart_command "/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
+  it "does not accept a regexp for the service restart command" do
     expect do
-      @resource.restart_command /.*/
+      resource.restart_command /.*/
     end.to raise_error(ArgumentError)
   end
 
-  it "should accept a string for the service reload command" do
-    @resource.reload_command "/etc/init.d/chef reload"
-    expect(@resource.reload_command).to eql("/etc/init.d/chef reload")
+  it "accepts a string for the service reload command" do
+    resource.reload_command "/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
+  it "does not accept a regexp for the service reload command" do
     expect do
-      @resource.reload_command /.*/
+      resource.reload_command /.*/
     end.to raise_error(ArgumentError)
   end
 
-  it "should accept a string for the service init command" do
-    @resource.init_command "/etc/init.d/chef"
-    expect(@resource.init_command).to eql("/etc/init.d/chef")
+  it "accepts a string for the service init command" do
+    resource.init_command "/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
+  it "does not accept a regexp for the service init command" do
     expect do
-      @resource.init_command /.*/
+      resource.init_command /.*/
     end.to raise_error(ArgumentError)
   end
 
-  it "should accept an array for options" do
-    @resource.options ["-r", "-s"]
-    expect(@resource.options).to eql(["-r", "-s"])
+  it "accepts an array for options" do
+    resource.options ["-r", "-s"]
+    expect(resource.options).to eql(["-r", "-s"])
   end
 
-  it "should accept a string for options" do
-    @resource.options "-r"
-    expect(@resource.options).to eql(["-r"])
+  it "accepts a string for options" do
+    resource.options "-r"
+    expect(resource.options).to eql(["-r"])
   end
 
-  it "should accept a string with multiple flags for options" do
-    @resource.options "-r -s"
-    expect(@resource.options).to eql(["-r", "-s"])
+  it "accepts a string with multiple flags for options" do
+    resource.options "-r -s"
+    expect(resource.options).to eql(["-r", "-s"])
   end
 
-  it "should not accept a boolean for options" do
+  it "does not accept a boolean for options" do
     expect do
-      @resource.options true
+      resource.options true
     end.to raise_error(ArgumentError)
   end
 
   %w{enabled running}.each do |attrib|
-    it "should accept true for #{attrib}" do
-      @resource.send(attrib, true)
-      expect(@resource.send(attrib)).to eql(true)
+    it "accepts true for #{attrib}" do
+      resource.send(attrib, true)
+      expect(resource.send(attrib)).to eql(true)
     end
 
-    it "should accept false for #{attrib}" do
-      @resource.send(attrib, false)
-      expect(@resource.send(attrib)).to eql(false)
+    it "accepts false for #{attrib}" do
+      resource.send(attrib, false)
+      expect(resource.send(attrib)).to eql(false)
     end
 
-    it "should not accept a string for #{attrib}" do
-      expect { @resource.send(attrib, "poop") }.to raise_error(ArgumentError)
+    it "does not accept a string for #{attrib}" do
+      expect { resource.send(attrib, "poop") }.to raise_error(ArgumentError)
     end
 
-    it "should default all the feature support to nil" do
+    it "defaults all the feature support to nil" do
       support_hash = { :status => nil, :restart => nil, :reload => nil }
-      expect(@resource.supports).to eq(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
+    it "allows you to set what features this resource supports as a array" do
       support_array = [ :status, :restart ]
       support_hash = { :status => true, :restart => true }
-      @resource.supports(support_array)
-      expect(@resource.supports).to eq(support_hash)
+      resource.supports(support_array)
+      expect(resource.supports).to eq(support_hash)
     end
 
-    it "should allow you to set what features this resource supports as a hash" do
+    it "allows you to set what features this resource supports as a hash" do
       support_hash = { :status => true, :restart => true }
-      @resource.supports(support_hash)
-      expect(@resource.supports).to eq(support_hash)
+      resource.supports(support_hash)
+      expect(resource.supports).to eq(support_hash)
     end
   end
 
   describe "when it has pattern and supports" do
     before do
-      @resource.service_name("superfriend")
-      @resource.enabled(true)
-      @resource.running(false)
+      resource.service_name("superfriend")
+      resource.enabled(true)
+      resource.running(false)
     end
 
     it "describes its state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:enabled]).to eql(true)
       expect(state[:running]).to eql(false)
     end
 
     it "returns the service name as its identity" do
-      expect(@resource.identity).to eq("superfriend")
+      expect(resource.identity).to eq("superfriend")
     end
   end
 end

data/spec/unit/resource/smartos_package_spec.rb

@@ -30,4 +30,9 @@ describe Chef::Resource::SmartosPackage, "initialize" do
     platform_family: "smartos"
   )
 
+  let(:resource) { Chef::Resource::SmartosPackage.new("foo") }
+
+  it "sets the package_name to the name provided" do
+    expect(resource.package_name).to eql("foo")
+  end
 end

data/spec/unit/resource/solaris_package_spec.rb

@@ -32,11 +32,9 @@ describe Chef::Resource::SolarisPackage, "initialize" do
     )
   end
 
-  before(:each) do
-    @resource = Chef::Resource::SolarisPackage.new("foo")
-  end
+  let(:resource) { Chef::Resource::SolarisPackage.new("foo") }
 
-  it "should set the package_name to the name provided" do
-    expect(@resource.package_name).to eql("foo")
+  it "sets the package_name to the name provided" do
+    expect(resource.package_name).to eql("foo")
   end
 end

data/spec/unit/resource/subversion_spec.rb

@@ -28,44 +28,46 @@ describe Chef::Resource::Subversion do
     action: :install
   )
 
-  before do
-    @svn = Chef::Resource::Subversion.new("ohai, svn project!")
-  end
+  let(:resource) { Chef::Resource::Subversion.new("ohai, svn project!") }
 
   it "is a subclass of Resource::Scm" do
-    expect(@svn).to be_an_instance_of(Chef::Resource::Subversion)
-    expect(@svn).to be_a_kind_of(Chef::Resource::Scm)
+    expect(resource).to be_an_instance_of(Chef::Resource::Subversion)
+    expect(resource).to be_a_kind_of(Chef::Resource::Scm)
+  end
+
+  it "set destination property to the name_property" do
+    expect(resource.destination).to eq("ohai, svn project!")
   end
 
   it "allows the force_export action" do
-    expect(@svn.allowed_actions).to include(:force_export)
+    expect(resource.allowed_actions).to include(:force_export)
   end
 
   it "sets svn info arguments to --no-auth-cache by default" do
-    expect(@svn.svn_info_args).to eq("--no-auth-cache")
+    expect(resource.svn_info_args).to eq("--no-auth-cache")
   end
 
   it "resets svn info arguments to nil when given false in the setter" do
-    @svn.svn_info_args(false)
-    expect(@svn.svn_info_args).to be_nil
+    resource.svn_info_args(false)
+    expect(resource.svn_info_args).to be_nil
   end
 
   it "sets svn arguments to --no-auth-cache by default" do
-    expect(@svn.svn_arguments).to eq("--no-auth-cache")
+    expect(resource.svn_arguments).to eq("--no-auth-cache")
   end
 
   it "sets svn binary to nil by default" do
-    expect(@svn.svn_binary).to be_nil
+    expect(resource.svn_binary).to be_nil
   end
 
   it "resets svn arguments to nil when given false in the setter" do
-    @svn.svn_arguments(false)
-    expect(@svn.svn_arguments).to be_nil
+    resource.svn_arguments(false)
+    expect(resource.svn_arguments).to be_nil
   end
 
   it "hides password from custom exception message" do
-    @svn.svn_password "l33th4x0rpa$$w0rd"
-    e = @svn.customize_exception(Chef::Exceptions::Exec.new "Exception with password #{@svn.svn_password}")
-    expect(e.message.include?(@svn.svn_password)).to be_falsey
+    resource.svn_password "l33th4x0rpa$$w0rd"
+    e = resource.customize_exception(Chef::Exceptions::Exec.new "Exception with password #{resource.svn_password}")
+    expect(e.message.include?(resource.svn_password)).to be_falsey
   end
 end

data/spec/unit/resource/systemd_unit_spec.rb

@@ -19,12 +19,8 @@
 require "spec_helper"
 
 describe Chef::Resource::SystemdUnit do
-  before(:each) do
-    @resource = Chef::Resource::SystemdUnit.new("sysstat-collect.timer")
-  end
-
+  let(:resource) { Chef::Resource::SystemdUnit.new("sysstat-collect.timer") }
   let(:unit_content_string) { "[Unit]\nDescription = Run system activity accounting tool every 10 minutes\n\n[Timer]\nOnCalendar = *:00/10\n\n[Install]\nWantedBy = sysstat.service\n" }
-
   let(:unit_content_hash) do
     {
       "Unit" => {
@@ -40,76 +36,76 @@ describe Chef::Resource::SystemdUnit do
   end
 
   it "creates a new Chef::Resource::SystemdUnit" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::SystemdUnit)
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::SystemdUnit)
   end
 
-  it "should have a name" do
-    expect(@resource.name).to eql("sysstat-collect.timer")
+  it "has a name" do
+    expect(resource.name).to eql("sysstat-collect.timer")
   end
 
   it "has a default action of nothing" do
-    expect(@resource.action).to eql([:nothing])
+    expect(resource.action).to eql([:nothing])
   end
 
   it "supports appropriate unit actions" do
-    expect { @resource.action :create }.not_to raise_error
-    expect { @resource.action :delete }.not_to raise_error
-    expect { @resource.action :enable }.not_to raise_error
-    expect { @resource.action :disable }.not_to raise_error
-    expect { @resource.action :mask }.not_to raise_error
-    expect { @resource.action :unmask }.not_to raise_error
-    expect { @resource.action :start }.not_to raise_error
-    expect { @resource.action :stop }.not_to raise_error
-    expect { @resource.action :restart }.not_to raise_error
-    expect { @resource.action :reload }.not_to raise_error
-    expect { @resource.action :wrong }.to raise_error(ArgumentError)
+    expect { resource.action :create }.not_to raise_error
+    expect { resource.action :delete }.not_to raise_error
+    expect { resource.action :enable }.not_to raise_error
+    expect { resource.action :disable }.not_to raise_error
+    expect { resource.action :mask }.not_to raise_error
+    expect { resource.action :unmask }.not_to raise_error
+    expect { resource.action :start }.not_to raise_error
+    expect { resource.action :stop }.not_to raise_error
+    expect { resource.action :restart }.not_to raise_error
+    expect { resource.action :reload }.not_to raise_error
+    expect { resource.action :wrong }.to raise_error(ArgumentError)
   end
 
   it "accepts boolean state properties" do
-    expect { @resource.active false }.not_to raise_error
-    expect { @resource.active true }.not_to raise_error
-    expect { @resource.active "yes" }.to raise_error(ArgumentError)
+    expect { resource.active false }.not_to raise_error
+    expect { resource.active true }.not_to raise_error
+    expect { resource.active "yes" }.to raise_error(ArgumentError)
 
-    expect { @resource.enabled true }.not_to raise_error
-    expect { @resource.enabled false }.not_to raise_error
-    expect { @resource.enabled "no" }.to raise_error(ArgumentError)
+    expect { resource.enabled true }.not_to raise_error
+    expect { resource.enabled false }.not_to raise_error
+    expect { resource.enabled "no" }.to raise_error(ArgumentError)
 
-    expect { @resource.masked true }.not_to raise_error
-    expect { @resource.masked false }.not_to raise_error
-    expect { @resource.masked :nope }.to raise_error(ArgumentError)
+    expect { resource.masked true }.not_to raise_error
+    expect { resource.masked false }.not_to raise_error
+    expect { resource.masked :nope }.to raise_error(ArgumentError)
 
-    expect { @resource.static true }.not_to raise_error
-    expect { @resource.static false }.not_to raise_error
-    expect { @resource.static "yep" }.to raise_error(ArgumentError)
+    expect { resource.static true }.not_to raise_error
+    expect { resource.static false }.not_to raise_error
+    expect { resource.static "yep" }.to raise_error(ArgumentError)
   end
 
   it "accepts the content property" do
-    expect { @resource.content nil }.not_to raise_error
-    expect { @resource.content "test" }.not_to raise_error
-    expect { @resource.content({}) }.not_to raise_error
-    expect { @resource.content 5 }.to raise_error(ArgumentError)
+    expect { resource.content nil }.not_to raise_error
+    expect { resource.content "test" }.not_to raise_error
+    expect { resource.content({}) }.not_to raise_error
+    expect { resource.content 5 }.to raise_error(ArgumentError)
   end
 
   it "accepts the user property" do
-    expect { @resource.user nil }.not_to raise_error
-    expect { @resource.user "deploy" }.not_to raise_error
-    expect { @resource.user 5 }.to raise_error(ArgumentError)
+    expect { resource.user nil }.not_to raise_error
+    expect { resource.user "deploy" }.not_to raise_error
+    expect { resource.user 5 }.to raise_error(ArgumentError)
   end
 
   it "accepts the triggers_reload property" do
-    expect { @resource.triggers_reload true }.not_to raise_error
-    expect { @resource.triggers_reload false }.not_to raise_error
-    expect { @resource.triggers_reload "no" }.to raise_error(ArgumentError)
+    expect { resource.triggers_reload true }.not_to raise_error
+    expect { resource.triggers_reload false }.not_to raise_error
+    expect { resource.triggers_reload "no" }.to raise_error(ArgumentError)
   end
 
   it "reports its state" do
-    @resource.active true
-    @resource.enabled true
-    @resource.masked false
-    @resource.static false
-    @resource.content "test"
-    state = @resource.state_for_resource_reporter
+    resource.active true
+    resource.enabled true
+    resource.masked false
+    resource.static false
+    resource.content "test"
+    state = resource.state_for_resource_reporter
     expect(state[:active]).to eq(true)
     expect(state[:enabled]).to eq(true)
     expect(state[:masked]).to eq(false)
@@ -118,16 +114,16 @@ describe Chef::Resource::SystemdUnit do
   end
 
   it "returns the unit name as its identity" do
-    expect(@resource.identity).to eq("sysstat-collect.timer")
+    expect(resource.identity).to eq("sysstat-collect.timer")
   end
 
   it "serializes to ini with a string-formatted content property" do
-    @resource.content(unit_content_string)
-    expect(@resource.to_ini).to eq unit_content_string
+    resource.content(unit_content_string)
+    expect(resource.to_ini).to eq unit_content_string
   end
 
   it "serializes to ini with a hash-formatted content property" do
-    @resource.content(unit_content_hash)
-    expect(@resource.to_ini).to eq unit_content_string
+    resource.content(unit_content_hash)
+    expect(resource.to_ini).to eq unit_content_string
   end
 end