chef 13.6.4 → 13.7.16

data/spec/unit/resource/log_spec.rb

@@ -21,53 +21,49 @@ require "spec_helper"
 
 describe Chef::Resource::Log do
 
-  before(:each) do
-    @log_str = "this is my string to log"
-    @resource = Chef::Resource::Log.new(@log_str)
-  end
+  let(:log_str) { "this is my string to log" }
+  let(:resource) { Chef::Resource::Log.new(log_str) }
 
-  it "should create a new Chef::Resource::Log" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Log)
+  it "creates a new Chef::Resource::Log" do
+    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
-    expect(@resource.allowed_actions).to include(:write)
+    expect(resource.allowed_actions).to include(:write)
   end
 
-  it "should have a name of log" do
-    expect(@resource.resource_name).to eq(:log)
+  it "has a name of log" do
+    expect(resource.resource_name).to eq(:log)
   end
 
-  it "should allow you to set a log string" do
-    expect(@resource.name).to eq(@log_str)
+  it "allows you to set a log string" do
+    expect(resource.name).to eq(log_str)
   end
 
-  it "should set the message to the first argument to new" do
-    expect(@resource.message).to eq(@log_str)
+  it "sets the message to the first argument to new" do
+    expect(resource.message).to eq(log_str)
   end
 
-  it "should accept a string for the log message" do
-    @resource.message "this is different"
-    expect(@resource.message).to eq("this is different")
+  it "accepts a string for the log message" do
+    resource.message "this is different"
+    expect(resource.message).to eq("this is different")
   end
 
-  it "should accept a vaild level option" do
-    @resource.level :debug
-    @resource.level :info
-    @resource.level :warn
-    @resource.level :error
-    @resource.level :fatal
-    expect { @resource.level :unsupported }.to raise_error(ArgumentError)
+  it "accepts a vaild level option" do
+    resource.level :debug
+    resource.level :info
+    resource.level :warn
+    resource.level :error
+    resource.level :fatal
+    expect { resource.level :unsupported }.to raise_error(ArgumentError)
   end
 
   describe "when the identity is defined" do
-    before do
-      @resource = Chef::Resource::Log.new("ery day I'm loggin-in")
-    end
+    let(:resource) { Chef::Resource::Log.new("ery day I'm loggin-in") }
 
     it "returns the log string as its identity" do
-      expect(@resource.identity).to eq("ery day I'm loggin-in")
+      expect(resource.identity).to eq("ery day I'm loggin-in")
     end
   end
 end

data/spec/unit/resource/mdadm_spec.rb

@@ -21,86 +21,84 @@ require "spec_helper"
 
 describe Chef::Resource::Mdadm do
 
-  before(:each) do
-    @resource = Chef::Resource::Mdadm.new("fakey_fakerton")
-  end
+  let(:resource) { Chef::Resource::Mdadm.new("fakey_fakerton") }
 
-  it "should create a new Chef::Resource::Mdadm" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Mdadm)
+  it "creates a new Chef::Resource::Mdadm" do
+    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
-    expect(@resource.resource_name).to eql(:mdadm)
+  it "has a resource name of :mdadm" do
+    expect(resource.resource_name).to eql(:mdadm)
   end
 
-  it "should have a default action of create" do
-    expect(@resource.action).to eql([:create])
+  it "has a default action of create" do
+    expect(resource.action).to eql([:create])
   end
 
-  it "should accept create, assemble, stop as actions" do
-    expect { @resource.action :create }.not_to raise_error
-    expect { @resource.action :assemble }.not_to raise_error
-    expect { @resource.action :stop }.not_to raise_error
+  it "accepts create, assemble, stop as actions" do
+    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"
-    expect(@resource.raid_device).to eql("/dev/md3")
+  it "allows you to set the raid_device attribute" do
+    resource.raid_device "/dev/md3"
+    expect(resource.raid_device).to eql("/dev/md3")
   end
 
-  it "should allow you to set the chunk attribute" do
-    @resource.chunk 256
-    expect(@resource.chunk).to eql(256)
+  it "allows you to set the chunk attribute" do
+    resource.chunk 256
+    expect(resource.chunk).to eql(256)
   end
 
-  it "should allow you to set the level attribute" do
-    @resource.level 1
-    expect(@resource.level).to eql(1)
+  it "allows you to set the level attribute" do
+    resource.level 1
+    expect(resource.level).to eql(1)
   end
 
-  it "should allow you to set the metadata attribute" do
-    @resource.metadata "1.2"
-    expect(@resource.metadata).to eql("1.2")
+  it "allows you to set the metadata attribute" do
+    resource.metadata "1.2"
+    expect(resource.metadata).to eql("1.2")
   end
 
-  it "should allow you to set the bitmap attribute" do
-    @resource.bitmap "internal"
-    expect(@resource.bitmap).to eql("internal")
+  it "allows you to set the bitmap attribute" do
+    resource.bitmap "internal"
+    expect(resource.bitmap).to eql("internal")
   end
 
-  it "should allow you to set the layout attribute" do
-    @resource.layout "f2"
-    expect(@resource.layout).to eql("f2")
+  it "allows you to set the layout attribute" do
+    resource.layout "f2"
+    expect(resource.layout).to eql("f2")
   end
 
-  it "should allow you to set the devices attribute" do
-    @resource.devices ["/dev/sda", "/dev/sdb"]
-    expect(@resource.devices).to eql(["/dev/sda", "/dev/sdb"])
+  it "allows you to set the devices attribute" do
+    resource.devices ["/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
-    expect(@resource.exists).to eql(true)
+  it "allows you to set the exists attribute" do
+    resource.exists true
+    expect(resource.exists).to eql(true)
   end
 
   describe "when it has devices, level, and chunk" do
     before do
-      @resource.raid_device("raider")
-      @resource.devices(%w{device1 device2})
-      @resource.level(1)
-      @resource.chunk(42)
+      resource.raid_device("raider")
+      resource.devices(%w{device1 device2})
+      resource.level(1)
+      resource.chunk(42)
     end
 
     it "describes its state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:devices]).to eql(%w{device1 device2})
       expect(state[:level]).to eq(1)
       expect(state[:chunk]).to eq(42)
     end
 
     it "returns the raid device as its identity" do
-      expect(@resource.identity).to eq("raider")
+      expect(resource.identity).to eq("raider")
     end
   end
 

data/spec/unit/resource/mount_spec.rb

@@ -20,189 +20,187 @@
 require "spec_helper"
 
 describe Chef::Resource::Mount do
-  before(:each) do
-    @resource = Chef::Resource::Mount.new("filesystem")
-  end
+  let(:resource) { Chef::Resource::Mount.new("filesystem") }
 
-  it "should create a new Chef::Resource::Mount" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Mount)
+  it "creates a new Chef::Resource::Mount" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::Mount)
   end
 
-  it "should have a name" do
-    expect(@resource.name).to eql("filesystem")
+  it "has a name" do
+    expect(resource.name).to eql("filesystem")
   end
 
-  it "should set mount_point to the name" do
-    expect(@resource.mount_point).to eql("filesystem")
+  it "sets mount_point to the name" do
+    expect(resource.mount_point).to eql("filesystem")
   end
 
-  it "should have a default action of mount" do
-    expect(@resource.action).to eql([:mount])
+  it "has a default action of mount" do
+    expect(resource.action).to eql([:mount])
   end
 
-  it "should accept mount, umount, unmount and remount as actions" do
-    expect { @resource.action :mount }.not_to raise_error
-    expect { @resource.action :umount }.not_to raise_error
-    expect { @resource.action :unmount }.not_to raise_error
-    expect { @resource.action :remount }.not_to raise_error
-    expect { @resource.action :brooklyn }.to raise_error(ArgumentError)
+  it "accepts mount, umount, unmount and remount as actions" do
+    expect { resource.action :mount }.not_to raise_error
+    expect { resource.action :umount }.not_to raise_error
+    expect { resource.action :unmount }.not_to raise_error
+    expect { resource.action :remount }.not_to raise_error
+    expect { resource.action :brooklyn }.to raise_error(ArgumentError)
   end
 
-  it "should allow you to set the device attribute" do
-    @resource.device "/dev/sdb3"
-    expect(@resource.device).to eql("/dev/sdb3")
+  it "allows you to set the device attribute" do
+    resource.device "/dev/sdb3"
+    expect(resource.device).to eql("/dev/sdb3")
   end
 
-  it "should set fsck_device to '-' by default" do
-    expect(@resource.fsck_device).to eql("-")
+  it "sets fsck_device to '-' by default" do
+    expect(resource.fsck_device).to eql("-")
   end
 
-  it "should allow you to set the fsck_device attribute" do
-    @resource.fsck_device "/dev/rdsk/sdb3"
-    expect(@resource.fsck_device).to eql("/dev/rdsk/sdb3")
+  it "allows you to set the fsck_device attribute" do
+    resource.fsck_device "/dev/rdsk/sdb3"
+    expect(resource.fsck_device).to eql("/dev/rdsk/sdb3")
   end
 
-  it "should allow you to set the fstype attribute" do
-    @resource.fstype "nfs"
-    expect(@resource.fstype).to eql("nfs")
+  it "allows you to set the fstype attribute" do
+    resource.fstype "nfs"
+    expect(resource.fstype).to eql("nfs")
   end
 
-  it "should allow you to set the dump attribute" do
-    @resource.dump 1
-    expect(@resource.dump).to eql(1)
+  it "allows you to set the dump attribute" do
+    resource.dump 1
+    expect(resource.dump).to eql(1)
   end
 
-  it "should allow you to set the pass attribute" do
-    @resource.pass 1
-    expect(@resource.pass).to eql(1)
+  it "allows you to set the pass attribute" do
+    resource.pass 1
+    expect(resource.pass).to eql(1)
   end
 
-  it "should set the options attribute to defaults" do
-    expect(@resource.options).to eql(["defaults"])
+  it "sets the options attribute to defaults" do
+    expect(resource.options).to eql(["defaults"])
   end
 
-  it "should allow options to be sent as a string, and convert to array" do
-    @resource.options "rw,noexec"
-    expect(@resource.options).to be_a_kind_of(Array)
+  it "allows options to be sent as a string, and convert to array" do
+    resource.options "rw,noexec"
+    expect(resource.options).to be_a_kind_of(Array)
   end
 
-  it "should allow options attribute as an array" do
-    @resource.options %w{ro nosuid}
-    expect(@resource.options).to be_a_kind_of(Array)
+  it "allows options attribute as an array" do
+    resource.options %w{ro nosuid}
+    expect(resource.options).to be_a_kind_of(Array)
   end
 
-  it "should allow options to be sent as a delayed evaluator" do
-    @resource.options Chef::DelayedEvaluator.new { %w{rw noexec} }
-    expect(@resource.options).to eql(%w{rw noexec})
+  it "allows options to be sent as a delayed evaluator" do
+    resource.options Chef::DelayedEvaluator.new { %w{rw noexec} }
+    expect(resource.options).to eql(%w{rw noexec})
   end
 
-  it "should allow options to be sent as a delayed evaluator, and convert to array" do
-    @resource.options Chef::DelayedEvaluator.new { "rw,noexec" }
-    expect(@resource.options).to be_a_kind_of(Array)
-    expect(@resource.options).to eql(%w{rw noexec})
+  it "allows options to be sent as a delayed evaluator, and convert to array" do
+    resource.options Chef::DelayedEvaluator.new { "rw,noexec" }
+    expect(resource.options).to be_a_kind_of(Array)
+    expect(resource.options).to eql(%w{rw noexec})
   end
 
-  it "should accept true for mounted" do
-    @resource.mounted(true)
-    expect(@resource.mounted).to eql(true)
+  it "accepts true for mounted" do
+    resource.mounted(true)
+    expect(resource.mounted).to eql(true)
   end
 
-  it "should accept false for mounted" do
-    @resource.mounted(false)
-    expect(@resource.mounted).to eql(false)
+  it "accepts false for mounted" do
+    resource.mounted(false)
+    expect(resource.mounted).to eql(false)
   end
 
-  it "should set mounted to false by default" do
-    expect(@resource.mounted).to eql(false)
+  it "sets mounted to false by default" do
+    expect(resource.mounted).to eql(false)
   end
 
-  it "should not accept a string for mounted" do
-    expect { @resource.mounted("poop") }.to raise_error(ArgumentError)
+  it "does not accept a string for mounted" do
+    expect { resource.mounted("poop") }.to raise_error(ArgumentError)
   end
 
-  it "should accept true for enabled" do
-    @resource.enabled(true)
-    expect(@resource.enabled).to eql(true)
+  it "accepts true for enabled" do
+    resource.enabled(true)
+    expect(resource.enabled).to eql(true)
   end
 
-  it "should accept false for enabled" do
-    @resource.enabled(false)
-    expect(@resource.enabled).to eql(false)
+  it "accepts false for enabled" do
+    resource.enabled(false)
+    expect(resource.enabled).to eql(false)
   end
 
-  it "should set enabled to false by default" do
-    expect(@resource.enabled).to eql(false)
+  it "sets enabled to false by default" do
+    expect(resource.enabled).to eql(false)
   end
 
-  it "should not accept a string for enabled" do
-    expect { @resource.enabled("poop") }.to raise_error(ArgumentError)
+  it "does not accept a string for enabled" do
+    expect { resource.enabled("poop") }.to raise_error(ArgumentError)
   end
 
-  it "should default all feature support to false" do
+  it "defaults all feature support to false" do
     support_hash = { :remount => false }
-    expect(@resource.supports).to eq(support_hash)
+    expect(resource.supports).to eq(support_hash)
   end
 
-  it "should allow you to set feature support as an array" do
+  it "allows you to set feature support as an array" do
     support_array = [ :remount ]
     support_hash = { :remount => 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 feature support as a hash" do
+  it "allows you to set feature support as a hash" do
     support_hash = { :remount => true }
-    @resource.supports(support_hash)
-    expect(@resource.supports).to eq(support_hash)
+    resource.supports(support_hash)
+    expect(resource.supports).to eq(support_hash)
   end
 
-  it "should allow you to set username" do
-    @resource.username("Administrator")
-    expect(@resource.username).to eq("Administrator")
+  it "allows you to set username" do
+    resource.username("Administrator")
+    expect(resource.username).to eq("Administrator")
   end
 
-  it "should allow you to set password" do
-    @resource.password("Jetstream123!")
-    expect(@resource.password).to eq("Jetstream123!")
+  it "allows you to set password" do
+    resource.password("Jetstream123!")
+    expect(resource.password).to eq("Jetstream123!")
   end
 
-  it "should allow you to set domain" do
-    @resource.domain("TEST_DOMAIN")
-    expect(@resource.domain).to eq("TEST_DOMAIN")
+  it "allows you to set domain" do
+    resource.domain("TEST_DOMAIN")
+    expect(resource.domain).to eq("TEST_DOMAIN")
   end
 
   describe "when it has mount point, device type, and fstype" do
     before do
-      @resource.device("charmander")
-      @resource.mount_point("123.456")
-      @resource.device_type(:device)
-      @resource.fstype("ranked")
+      resource.device("charmander")
+      resource.mount_point("123.456")
+      resource.device_type(:device)
+      resource.fstype("ranked")
     end
 
     it "describes its state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:mount_point]).to eq("123.456")
       expect(state[:device_type]).to eql(:device)
       expect(state[:fstype]).to eq("ranked")
     end
 
     it "returns the device as its identity" do
-      expect(@resource.identity).to eq("charmander")
+      expect(resource.identity).to eq("charmander")
     end
   end
 
   describe "when it has username, password and domain" do
     before do
-      @resource.mount_point("T:")
-      @resource.device("charmander")
-      @resource.username("Administrator")
-      @resource.password("Jetstream123!")
-      @resource.domain("TEST_DOMAIN")
+      resource.mount_point("T:")
+      resource.device("charmander")
+      resource.username("Administrator")
+      resource.password("Jetstream123!")
+      resource.domain("TEST_DOMAIN")
     end
 
     it "describes its state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:mount_point]).to eq("T:")
       expect(state[:username]).to eq("Administrator")
       expect(state[:password]).to eq("*sensitive value suppressed*")