chef 13.6.4-universal-mingw32 → 13.7.16-universal-mingw32

data/spec/unit/resource/route_spec.rb

@@ -21,87 +21,85 @@ require "spec_helper"
 
 describe Chef::Resource::Route do
 
-  before(:each) do
-    @resource = Chef::Resource::Route.new("10.0.0.10")
-  end
+  let(:resource) { Chef::Resource::Route.new("10.0.0.10") }
 
-  it "should create a new Chef::Resource::Route" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Route)
+  it "creates a new Chef::Resource::Route" do
+    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
-    expect(@resource.name).to eql("10.0.0.10")
+  it "has a name" do
+    expect(resource.name).to eql("10.0.0.10")
   end
 
-  it "should have a default action of 'add'" do
-    expect(@resource.action).to eql([:add])
+  it "has a default action of 'add'" do
+    expect(resource.action).to eql([:add])
   end
 
-  it "should accept add or delete for action" do
-    expect { @resource.action :add }.not_to raise_error
-    expect { @resource.action :delete }.not_to raise_error
-    expect { @resource.action :lolcat }.to raise_error(ArgumentError)
+  it "accepts add or delete for action" do
+    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
-    expect(@resource.target).to eql("10.0.0.10")
+  it "uses the object name as the target by default" do
+    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"
-    expect(@resource.netmask).to eql("255.255.255.0")
+  it "allows you to specify the netmask" do
+    resource.netmask "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"
-    expect(@resource.gateway).to eql("10.0.0.1")
+  it "allows you to specify the gateway" do
+    resource.gateway "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
-    expect(@resource.metric).to eql(10)
+  it "allows you to specify the metric" do
+    resource.metric 10
+    expect(resource.metric).to eql(10)
   end
 
-  it "should allow you to specify the device" do
-    @resource.device "eth0"
-    expect(@resource.device).to eql("eth0")
+  it "allows you to specify the device" do
+    resource.device "eth0"
+    expect(resource.device).to eql("eth0")
   end
 
-  it "should allow you to specify the route type" do
-    @resource.route_type "host"
-    expect(@resource.route_type).to eql(:host)
+  it "allows you to specify the route type" do
+    resource.route_type "host"
+    expect(resource.route_type).to eql(:host)
   end
 
-  it "should default to a host route type" do
-    expect(@resource.route_type).to eql(:host)
+  it "defaults to a host route type" do
+    expect(resource.route_type).to eql(:host)
   end
 
-  it "should accept a net route type" do
-    @resource.route_type :net
-    expect(@resource.route_type).to eql(:net)
+  it "accepts a net route type" do
+    resource.route_type :net
+    expect(resource.route_type).to eql(:net)
   end
 
-  it "should reject any other route_type but :host and :net" do
-    expect { @resource.route_type "lolcat" }.to raise_error(ArgumentError)
+  it "rejects any other route_type but :host and :net" do
+    expect { resource.route_type "lolcat" }.to raise_error(ArgumentError)
   end
 
   describe "when it has netmask, gateway, and device" do
     before do
-      @resource.target("charmander")
-      @resource.netmask("lemask")
-      @resource.gateway("111.111.111")
-      @resource.device("forcefield")
+      resource.target("charmander")
+      resource.netmask("lemask")
+      resource.gateway("111.111.111")
+      resource.device("forcefield")
     end
 
     it "describes its state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:netmask]).to eq("lemask")
       expect(state[:gateway]).to eq("111.111.111")
     end
 
     it "returns the target  as its identity" do
-      expect(@resource.identity).to eq("charmander")
+      expect(resource.identity).to eq("charmander")
     end
   end
 end

data/spec/unit/resource/rpm_package_spec.rb

@@ -34,13 +34,11 @@ describe Chef::Resource::RpmPackage, "initialize" do
 end
 
 describe Chef::Resource::RpmPackage, "allow_downgrade" do
-  before(:each) do
-    @resource = Chef::Resource::RpmPackage.new("foo")
-  end
+  let(:resource) { Chef::Resource::RpmPackage.new("foo") }
 
-  it "should allow you to specify whether allow_downgrade is true or false" do
-    expect { @resource.allow_downgrade true }.not_to raise_error
-    expect { @resource.allow_downgrade false }.not_to raise_error
-    expect { @resource.allow_downgrade "monkey" }.to raise_error(ArgumentError)
+  it "allows you to specify whether allow_downgrade is true or false" do
+    expect { resource.allow_downgrade true }.not_to raise_error
+    expect { resource.allow_downgrade false }.not_to raise_error
+    expect { resource.allow_downgrade "monkey" }.to raise_error(ArgumentError)
   end
 end

data/spec/unit/resource/ruby_block_spec.rb

@@ -21,41 +21,39 @@ require "spec_helper"
 
 describe Chef::Resource::RubyBlock do
 
-  before(:each) do
-    @resource = Chef::Resource::RubyBlock.new("fakey_fakerton")
-  end
+  let(:resource) { Chef::Resource::RubyBlock.new("fakey_fakerton") }
 
-  it "should create a new Chef::Resource::RubyBlock" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::RubyBlock)
+  it "creates a new Chef::Resource::RubyBlock" do
+    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 'run'" do
-    expect(@resource.action).to eql([:run])
+  it "has a default action of 'run'" do
+    expect(resource.action).to eql([:run])
   end
 
-  it "should have a resource name of :ruby_block" do
-    expect(@resource.resource_name).to eql(:ruby_block)
+  it "has a resource name of :ruby_block" do
+    expect(resource.resource_name).to eql(:ruby_block)
   end
 
-  it "should accept a ruby block/proc/.. for the 'block' parameter" do
-    expect(@resource.block do
+  it "accepts a ruby block/proc/.. for the 'block' parameter" do
+    expect(resource.block do
       "foo"
     end.call).to eql("foo")
   end
 
   it "allows the action to be 'create'" do
-    @resource.action :create
-    expect(@resource.action).to eq([:create])
+    resource.action :create
+    expect(resource.action).to eq([:create])
   end
 
   describe "when it has been initialized with block code" do
     before do
-      @resource.block_name("puts 'harrrr'")
+      resource.block_name("puts 'harrrr'")
     end
 
     it "returns the block as its identity" do
-      expect(@resource.identity).to eq("puts 'harrrr'")
+      expect(resource.identity).to eq("puts 'harrrr'")
     end
   end
 end

data/spec/unit/resource/ruby_spec.rb

@@ -19,22 +19,18 @@
 require "spec_helper"
 
 describe Chef::Resource::Ruby do
+  let(:resource) { Chef::Resource::Ruby.new("fakey_fakerton") }
 
-  before(:each) do
-    @resource = Chef::Resource::Ruby.new("fakey_fakerton")
+  it "creates a new Chef::Resource::Ruby" do
+    expect(resource).to be_a_kind_of(Chef::Resource)
+    expect(resource).to be_a_kind_of(Chef::Resource::Ruby)
   end
 
-  it "should create a new Chef::Resource::Ruby" do
-    expect(@resource).to be_a_kind_of(Chef::Resource)
-    expect(@resource).to be_a_kind_of(Chef::Resource::Ruby)
+  it "has a resource name of :ruby" do
+    expect(resource.resource_name).to eql(:ruby)
   end
 
-  it "should have a resource name of :ruby" do
-    expect(@resource.resource_name).to eql(:ruby)
+  it "has an interpreter of ruby" do
+    expect(resource.interpreter).to eql("ruby")
   end
-
-  it "should have an interpreter of ruby" do
-    expect(@resource.interpreter).to eql("ruby")
-  end
-
 end

data/spec/unit/resource/scm_spec.rb

@@ -20,174 +20,171 @@
 require "spec_helper"
 
 describe Chef::Resource::Scm do
+  let(:resource) { Chef::Resource::Scm.new("my awesome app") }
 
-  before(:each) do
-    @resource = Chef::Resource::Scm.new("my awesome app")
-  end
-
-  it "should be a SCM resource" do
-    expect(@resource).to be_a_kind_of(Chef::Resource::Scm)
+  it "is a SCM resource" do
+    expect(resource).to be_a_kind_of(Chef::Resource::Scm)
   end
 
   it "supports :checkout, :export, :sync, :diff, and :log actions" do
-    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)
+    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"
-    expect(@resource.destination).to eql("/path/to/deploy/dir")
+    resource.destination "/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"
-    expect(@resource.repository).to eql("git://github.com/opscode/chef.git")
+    resource.repository "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"
-    expect(@resource.revision).to eql("abcdef")
+    resource.revision "abcdef"
+    expect(resource.revision).to eql("abcdef")
   end
 
   it "defaults to the ``HEAD'' revision" do
-    expect(@resource.revision).to eql("HEAD")
+    expect(resource.revision).to eql("HEAD")
   end
 
   it "takes a string for the user to run as" do
-    @resource.user "dr_deploy"
-    expect(@resource.user).to eql("dr_deploy")
+    resource.user "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
-    expect(@resource.user).to eql(0)
+    resource.user 0
+    expect(resource.user).to eql(0)
   end
 
   it "takes a string for the group to run as, defaulting to nil" do
-    expect(@resource.group).to be_nil
-    @resource.group "opsdevs"
-    expect(@resource.group).to eq("opsdevs")
+    expect(resource.group).to be_nil
+    resource.group "opsdevs"
+    expect(resource.group).to eq("opsdevs")
   end
 
   it "also takes an integer for the group to run as" do
-    @resource.group 23
-    expect(@resource.group).to eq(23)
+    resource.group 23
+    expect(resource.group).to eq(23)
   end
 
   it "has a svn_username String attribute" do
-    @resource.svn_username "moartestsplz"
-    expect(@resource.svn_username).to eql("moartestsplz")
+    resource.svn_username "moartestsplz"
+    expect(resource.svn_username).to eql("moartestsplz")
   end
 
   it "has a svn_password String attribute" do
-    @resource.svn_password "taftplz"
-    expect(@resource.svn_password).to eql("taftplz")
+    resource.svn_password "taftplz"
+    expect(resource.svn_password).to eql("taftplz")
   end
 
   it "has a svn_arguments String attribute" do
-    @resource.svn_arguments "--more-taft plz"
-    expect(@resource.svn_arguments).to eql("--more-taft plz")
+    resource.svn_arguments "--more-taft plz"
+    expect(resource.svn_arguments).to eql("--more-taft plz")
   end
 
   it "has a svn_info_args String attribute" do
-    expect(@resource.svn_info_args).to be_nil
-    @resource.svn_info_args("--no-moar-plaintext-creds yep")
-    expect(@resource.svn_info_args).to eq("--no-moar-plaintext-creds yep")
+    expect(resource.svn_info_args).to be_nil
+    resource.svn_info_args("--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
-    expect(@resource.depth).to eq(5)
-    expect { @resource.depth "five" }.to raise_error(ArgumentError)
+    resource.depth 5
+    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
-    expect(@resource.depth).to be_nil
+    expect(resource.depth).to be_nil
   end
 
   it "takes a boolean for #enable_submodules" do
-    @resource.enable_submodules true
-    expect(@resource.enable_submodules).to be_truthy
-    expect { @resource.enable_submodules "lolz" }.to raise_error(ArgumentError)
+    resource.enable_submodules true
+    expect(resource.enable_submodules).to be_truthy
+    expect { resource.enable_submodules "lolz" }.to raise_error(ArgumentError)
   end
 
   it "defaults to not enabling submodules" do
-    expect(@resource.enable_submodules).to be_falsey
+    expect(resource.enable_submodules).to be_falsey
   end
 
   it "takes a boolean for #enable_checkout" do
-    @resource.enable_checkout true
-    expect(@resource.enable_checkout).to be_truthy
-    expect { @resource.enable_checkout "lolz" }.to raise_error(ArgumentError)
+    resource.enable_checkout true
+    expect(resource.enable_checkout).to be_truthy
+    expect { resource.enable_checkout "lolz" }.to raise_error(ArgumentError)
   end
 
   it "defaults to enabling checkout" do
-    expect(@resource.enable_checkout).to be_truthy
+    expect(resource.enable_checkout).to be_truthy
   end
 
   it "takes a string for the remote" do
-    @resource.remote "opscode"
-    expect(@resource.remote).to eql("opscode")
-    expect { @resource.remote 1337 }.to raise_error(ArgumentError)
+    resource.remote "opscode"
+    expect(resource.remote).to eql("opscode")
+    expect { resource.remote 1337 }.to raise_error(ArgumentError)
   end
 
   it "defaults to ``origin'' for the remote" do
-    expect(@resource.remote).to eq("origin")
+    expect(resource.remote).to eq("origin")
   end
 
   it "takes a string for the ssh wrapper" do
-    @resource.ssh_wrapper "with_ssh_fu"
-    expect(@resource.ssh_wrapper).to eql("with_ssh_fu")
+    resource.ssh_wrapper "with_ssh_fu"
+    expect(resource.ssh_wrapper).to eql("with_ssh_fu")
   end
 
   it "defaults to nil for the ssh wrapper" do
-    expect(@resource.ssh_wrapper).to be_nil
+    expect(resource.ssh_wrapper).to be_nil
   end
 
   it "defaults to nil for the environment" do
-    expect(@resource.environment).to 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) }
+    before { resource.timeout(ten_seconds) }
     it "stores this timeout" do
-      expect(@resource.timeout).to eq(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
-      expect(@resource.timeout).to be_nil
+    it "has no default timeout" do
+      expect(resource.timeout).to be_nil
     end
   end
 
   describe "when it has repository, revision, user, and group" do
     before do
-      @resource.destination("hell")
-      @resource.repository("apt")
-      @resource.revision("1.2.3")
-      @resource.user("root")
-      @resource.group("super_adventure_club")
+      resource.destination("hell")
+      resource.repository("apt")
+      resource.revision("1.2.3")
+      resource.user("root")
+      resource.group("super_adventure_club")
     end
 
     it "describes its state" do
-      state = @resource.state_for_resource_reporter
+      state = resource.state_for_resource_reporter
       expect(state[:revision]).to eq("1.2.3")
     end
 
     it "returns the destination as its identity" do
-      expect(@resource.identity).to eq("hell")
+      expect(resource.identity).to eq("hell")
     end
   end
 
   describe "when it has a environment attribute" do
     let(:test_environment) { { "CHEF_ENV" => "/tmp" } }
-    before { @resource.environment(test_environment) }
+    before { resource.environment(test_environment) }
     it "stores this environment" do
-      expect(@resource.environment).to eq(test_environment)
+      expect(resource.environment).to eq(test_environment)
     end
   end
 end