diff options
Diffstat (limited to 'spec/unit/resource')
50 files changed, 671 insertions, 671 deletions
diff --git a/spec/unit/resource/apt_package_spec.rb b/spec/unit/resource/apt_package_spec.rb index 9503e0cbe1..be8eb9c324 100644 --- a/spec/unit/resource/apt_package_spec.rb +++ b/spec/unit/resource/apt_package_spec.rb @@ -35,6 +35,6 @@ describe Chef::Resource::AptPackage, "initialize" do it "should support default_release" do @resource.default_release("lenny-backports") - @resource.default_release.should eql("lenny-backports") + expect(@resource.default_release).to eql("lenny-backports") end end diff --git a/spec/unit/resource/bash_spec.rb b/spec/unit/resource/bash_spec.rb index d729db6977..f313900433 100644 --- a/spec/unit/resource/bash_spec.rb +++ b/spec/unit/resource/bash_spec.rb @@ -25,16 +25,16 @@ describe Chef::Resource::Bash do end it "should create a new Chef::Resource::Bash" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Bash) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::Bash) end it "should have a resource name of :bash" do - @resource.resource_name.should eql(:bash) + expect(@resource.resource_name).to eql(:bash) end it "should have an interpreter of bash" do - @resource.interpreter.should eql("bash") + expect(@resource.interpreter).to eql("bash") end end diff --git a/spec/unit/resource/batch_spec.rb b/spec/unit/resource/batch_spec.rb index b74c7d24a7..4a056b8735 100644 --- a/spec/unit/resource/batch_spec.rb +++ b/spec/unit/resource/batch_spec.rb @@ -33,7 +33,7 @@ describe Chef::Resource::Batch do end it "should create a new Chef::Resource::Batch" do - @resource.should be_a_kind_of(Chef::Resource::Batch) + expect(@resource).to be_a_kind_of(Chef::Resource::Batch) end context "windows script" do diff --git a/spec/unit/resource/breakpoint_spec.rb b/spec/unit/resource/breakpoint_spec.rb index ed655b84a6..ed1f3ebcd5 100644 --- a/spec/unit/resource/breakpoint_spec.rb +++ b/spec/unit/resource/breakpoint_spec.rb @@ -33,15 +33,15 @@ describe Chef::Resource::Breakpoint do end it "allows the action :break" do - @breakpoint.allowed_actions.should include(:break) + expect(@breakpoint.allowed_actions).to include(:break) end it "defaults to the break action" do - @breakpoint.action.should == "break" + expect(@breakpoint.action).to eq("break") end it "names itself after the line number of the file where it's created" do - @breakpoint.name.should match(/breakpoint_spec\.rb\:[\d]{2}\:in \`new\'$/) + expect(@breakpoint.name).to match(/breakpoint_spec\.rb\:[\d]{2}\:in \`new\'$/) end end diff --git a/spec/unit/resource/chef_gem_spec.rb b/spec/unit/resource/chef_gem_spec.rb index 6a419b3f3b..480856d19f 100644 --- a/spec/unit/resource/chef_gem_spec.rb +++ b/spec/unit/resource/chef_gem_spec.rb @@ -38,7 +38,7 @@ describe Chef::Resource::ChefGem, "gem_binary" do end it "should raise an exception when gem_binary is set" do - lambda { @resource.gem_binary("/lol/cats/gem") }.should raise_error(ArgumentError) + expect { @resource.gem_binary("/lol/cats/gem") }.to raise_error(ArgumentError) end it "should set the gem_binary based on computing it from RbConfig" do diff --git a/spec/unit/resource/conditional_action_not_nothing_spec.rb b/spec/unit/resource/conditional_action_not_nothing_spec.rb index 49bc0ad57d..9f29de55f2 100644 --- a/spec/unit/resource/conditional_action_not_nothing_spec.rb +++ b/spec/unit/resource/conditional_action_not_nothing_spec.rb @@ -27,7 +27,7 @@ describe Chef::Resource::ConditionalActionNotNothing do end it "indicates that resource convergence should not continue" do - @conditional.continue?.should be_false + expect(@conditional.continue?).to be_false end end @@ -38,7 +38,7 @@ describe Chef::Resource::ConditionalActionNotNothing do end it "indicates that resource convergence should continue" do - @conditional.continue?.should be_true + expect(@conditional.continue?).to be_true end end diff --git a/spec/unit/resource/conditional_spec.rb b/spec/unit/resource/conditional_spec.rb index 1fc2518013..cacac925b7 100644 --- a/spec/unit/resource/conditional_spec.rb +++ b/spec/unit/resource/conditional_spec.rb @@ -21,9 +21,9 @@ require 'ostruct' describe Chef::Resource::Conditional do before do - Mixlib::ShellOut.any_instance.stub(:run_command).and_return(nil) + allow_any_instance_of(Mixlib::ShellOut).to receive(:run_command).and_return(nil) @status = OpenStruct.new(:success? => true) - Mixlib::ShellOut.any_instance.stub(:status).and_return(@status) + allow_any_instance_of(Mixlib::ShellOut).to receive(:status).and_return(@status) @parent_resource = Chef::Resource.new(nil, Chef::Node.new) end @@ -53,7 +53,7 @@ describe Chef::Resource::Conditional do end it "indicates that resource convergence should continue" do - @conditional.continue?.should be_true + expect(@conditional.continue?).to be_true end end @@ -64,22 +64,22 @@ describe Chef::Resource::Conditional do end it "indicates that resource convergence should not continue" do - @conditional.continue?.should be_false + expect(@conditional.continue?).to be_false end end describe 'after running a command which timed out' do before do @conditional = Chef::Resource::Conditional.only_if(@parent_resource, "false") - Chef::GuardInterpreter::DefaultGuardInterpreter.any_instance.stub(:shell_out).and_raise(Chef::Exceptions::CommandTimeout) + allow_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).to receive(:shell_out).and_raise(Chef::Exceptions::CommandTimeout) end it 'indicates that resource convergence should not continue' do - @conditional.continue?.should be_false + expect(@conditional.continue?).to be_false end it 'should log a warning' do - Chef::Log.should_receive(:warn).with("Command 'false' timed out") + expect(Chef::Log).to receive(:warn).with("Command 'false' timed out") @conditional.continue? end end @@ -90,7 +90,7 @@ describe Chef::Resource::Conditional do end it "indicates that resource convergence should continue" do - @conditional.continue?.should be_true + expect(@conditional.continue?).to be_true end end @@ -100,7 +100,7 @@ describe Chef::Resource::Conditional do end it "indicates that resource convergence should not continue" do - @conditional.continue?.should be_false + expect(@conditional.continue?).to be_false end end end @@ -112,7 +112,7 @@ describe Chef::Resource::Conditional do end it "indicates that resource convergence should not continue" do - @conditional.continue?.should be_false + expect(@conditional.continue?).to be_false end end @@ -123,22 +123,22 @@ describe Chef::Resource::Conditional do end it "indicates that resource convergence should continue" do - @conditional.continue?.should be_true + expect(@conditional.continue?).to be_true end end describe 'after running a command which timed out' do before do @conditional = Chef::Resource::Conditional.not_if(@parent_resource, "false") - Chef::GuardInterpreter::DefaultGuardInterpreter.any_instance.stub(:shell_out).and_raise(Chef::Exceptions::CommandTimeout) + allow_any_instance_of(Chef::GuardInterpreter::DefaultGuardInterpreter).to receive(:shell_out).and_raise(Chef::Exceptions::CommandTimeout) end it 'indicates that resource convergence should continue' do - @conditional.continue?.should be_true + expect(@conditional.continue?).to be_true end it 'should log a warning' do - Chef::Log.should_receive(:warn).with("Command 'false' timed out") + expect(Chef::Log).to receive(:warn).with("Command 'false' timed out") @conditional.continue? end end @@ -149,7 +149,7 @@ describe Chef::Resource::Conditional do end it "indicates that resource convergence should not continue" do - @conditional.continue?.should be_false + expect(@conditional.continue?).to be_false end end @@ -159,7 +159,7 @@ describe Chef::Resource::Conditional do end it "indicates that resource convergence should continue" do - @conditional.continue?.should be_true + expect(@conditional.continue?).to be_true end end end diff --git a/spec/unit/resource/cookbook_file_spec.rb b/spec/unit/resource/cookbook_file_spec.rb index 6c55c8035a..834e08bba4 100644 --- a/spec/unit/resource/cookbook_file_spec.rb +++ b/spec/unit/resource/cookbook_file_spec.rb @@ -25,25 +25,25 @@ describe Chef::Resource::CookbookFile do end it "uses the name parameter for the source parameter" do - @cookbook_file.name.should == 'sourcecode_tarball.tgz' + expect(@cookbook_file.name).to eq('sourcecode_tarball.tgz') end it "has a source parameter" do @cookbook_file.name('config_file.conf') - @cookbook_file.name.should == 'config_file.conf' + expect(@cookbook_file.name).to eq('config_file.conf') end it "defaults to a nil cookbook parameter (current cookbook will be used)" do - @cookbook_file.cookbook.should be_nil + expect(@cookbook_file.cookbook).to be_nil end it "has a cookbook parameter" do @cookbook_file.cookbook("munin") - @cookbook_file.cookbook.should == 'munin' + expect(@cookbook_file.cookbook).to eq('munin') end it "sets the provider to Chef::Provider::CookbookFile" do - @cookbook_file.provider.should == Chef::Provider::CookbookFile + expect(@cookbook_file.provider).to eq(Chef::Provider::CookbookFile) end describe "when it has a backup number, group, mode, owner, source, checksum, and cookbook on nix or path, rights, deny_rights, checksum on windows" do @@ -68,21 +68,21 @@ describe Chef::Resource::CookbookFile do state = @cookbook_file.state if Chef::Platform.windows? puts state - state[:rights].should == [{:permissions => :read, :principals => "Everyone"}] - state[:deny_rights].should == [{:permissions => :full_control, :principals => "Clumsy_Sam"}] + expect(state[:rights]).to eq([{:permissions => :read, :principals => "Everyone"}]) + expect(state[:deny_rights]).to eq([{:permissions => :full_control, :principals => "Clumsy_Sam"}]) else - state[:group].should == "wheel" - state[:mode].should == "0664" - state[:owner].should == "root" + expect(state[:group]).to eq("wheel") + expect(state[:mode]).to eq("0664") + expect(state[:owner]).to eq("root") end - state[:checksum].should == "1" * 64 + expect(state[:checksum]).to eq("1" * 64) end it "returns the path as its identity" do if Chef::Platform.windows? - @cookbook_file.identity.should == "C:/temp/origin/file.txt" + expect(@cookbook_file.identity).to eq("C:/temp/origin/file.txt") else - @cookbook_file.identity.should == "/tmp/origin/file.txt" + expect(@cookbook_file.identity).to eq("/tmp/origin/file.txt") end end end diff --git a/spec/unit/resource/cron_spec.rb b/spec/unit/resource/cron_spec.rb index cf821e3d32..743552c1de 100644 --- a/spec/unit/resource/cron_spec.rb +++ b/spec/unit/resource/cron_spec.rb @@ -26,135 +26,135 @@ describe Chef::Resource::Cron do end it "should create a new Chef::Resource::Cron" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Cron) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::Cron) end it "should have a name" do - @resource.name.should eql("cronify") + expect(@resource.name).to eql("cronify") 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 or delete for action" do - lambda { @resource.action :create }.should_not raise_error - lambda { @resource.action :delete }.should_not raise_error - lambda { @resource.action :lolcat }.should raise_error(ArgumentError) + expect { @resource.action :create }.not_to raise_error + expect { @resource.action :delete }.not_to raise_error + expect { @resource.action :lolcat }.to raise_error(ArgumentError) end it "should allow you to set a command" do @resource.command "/bin/true" - @resource.command.should eql("/bin/true") + expect(@resource.command).to eql("/bin/true") end it "should allow you to set a user" do @resource.user "daemon" - @resource.user.should eql("daemon") + expect(@resource.user).to eql("daemon") end it "should allow you to specify the minute" do @resource.minute "30" - @resource.minute.should eql("30") + expect(@resource.minute).to eql("30") end it "should allow you to specify the hour" do @resource.hour "6" - @resource.hour.should eql("6") + expect(@resource.hour).to eql("6") end it "should allow you to specify the day" do @resource.day "10" - @resource.day.should eql("10") + expect(@resource.day).to eql("10") end it "should allow you to specify the month" do @resource.month "10" - @resource.month.should eql("10") + expect(@resource.month).to eql("10") end it "should allow you to specify the weekday" do @resource.weekday "2" - @resource.weekday.should eql("2") + expect(@resource.weekday).to eql("2") end it "should allow you to specify the mailto variable" do @resource.mailto "test@example.com" - @resource.mailto.should eql("test@example.com") + expect(@resource.mailto).to eql("test@example.com") end it "should allow you to specify the path" do @resource.path "/usr/bin:/usr/sbin" - @resource.path.should eql("/usr/bin:/usr/sbin") + expect(@resource.path).to eql("/usr/bin:/usr/sbin") end it "should allow you to specify the home directory" do @resource.home "/root" - @resource.home.should eql("/root") + expect(@resource.home).to eql("/root") end it "should allow you to specify the shell to run the command with" do @resource.shell "/bin/zsh" - @resource.shell.should eql("/bin/zsh") + expect(@resource.shell).to eql("/bin/zsh") end it "should allow you to specify environment variables hash" do env = {"TEST" => "LOL"} @resource.environment env - @resource.environment.should eql(env) + expect(@resource.environment).to eql(env) end it "should allow * for all time and date values" do [ "minute", "hour", "day", "month", "weekday" ].each do |x| - @resource.send(x, "*").should eql("*") + expect(@resource.send(x, "*")).to eql("*") end end it "should allow ranges for all time and date values" do [ "minute", "hour", "day", "month", "weekday" ].each do |x| - @resource.send(x, "1-2,5").should eql("1-2,5") + expect(@resource.send(x, "1-2,5")).to eql("1-2,5") end end it "should have a default value of * for all time and date values" do [ "minute", "hour", "day", "month", "weekday" ].each do |x| - @resource.send(x).should eql("*") + expect(@resource.send(x)).to eql("*") end end it "should have a default value of root for the user" do - @resource.user.should eql("root") + expect(@resource.user).to eql("root") end it "should reject any minute over 59" do - lambda { @resource.minute "60" }.should raise_error(RangeError) + expect { @resource.minute "60" }.to raise_error(RangeError) end it "should reject any hour over 23" do - lambda { @resource.hour "24" }.should raise_error(RangeError) + expect { @resource.hour "24" }.to raise_error(RangeError) end it "should reject any day over 31" do - lambda { @resource.day "32" }.should raise_error(RangeError) + expect { @resource.day "32" }.to raise_error(RangeError) end it "should reject any month over 12" do - lambda { @resource.month "13" }.should raise_error(RangeError) + expect { @resource.month "13" }.to raise_error(RangeError) end describe "weekday" do it "should reject any weekday over 7" do - lambda { @resource.weekday "8" }.should raise_error(RangeError) + expect { @resource.weekday "8" }.to raise_error(RangeError) end it "should reject any symbols which don't represent day of week" do - lambda { @resource.weekday :foo }.should raise_error(RangeError) + expect { @resource.weekday :foo }.to raise_error(RangeError) end end it "should convert integer schedule values to a string" do [ "minute", "hour", "day", "month", "weekday" ].each do |x| - @resource.send(x, 5).should eql("5") + expect(@resource.send(x, 5)).to eql("5") end end @@ -171,16 +171,16 @@ describe Chef::Resource::Cron do it "describes the state" do state = @resource.state - state[:minute].should == "1" - state[:hour].should == "2" - state[:day].should == "3" - state[:month].should == "4" - state[:weekday].should == "5" - state[:user].should == "root" + expect(state[:minute]).to eq("1") + expect(state[:hour]).to eq("2") + expect(state[:day]).to eq("3") + expect(state[:month]).to eq("4") + expect(state[:weekday]).to eq("5") + expect(state[:user]).to eq("root") end it "returns the command as its identity" do - @resource.identity.should == "tackle" + expect(@resource.identity).to eq("tackle") end end end diff --git a/spec/unit/resource/csh_spec.rb b/spec/unit/resource/csh_spec.rb index e1534a8f5f..5fb3b00507 100644 --- a/spec/unit/resource/csh_spec.rb +++ b/spec/unit/resource/csh_spec.rb @@ -25,16 +25,16 @@ describe Chef::Resource::Csh do end it "should create a new Chef::Resource::Csh" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Csh) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::Csh) end it "should have a resource name of :csh" do - @resource.resource_name.should eql(:csh) + expect(@resource.resource_name).to eql(:csh) end it "should have an interpreter of csh" do - @resource.interpreter.should eql("csh") + expect(@resource.interpreter).to eql("csh") end end diff --git a/spec/unit/resource/deploy_spec.rb b/spec/unit/resource/deploy_spec.rb index 914ea19030..6592fae26c 100644 --- a/spec/unit/resource/deploy_spec.rb +++ b/spec/unit/resource/deploy_spec.rb @@ -33,28 +33,28 @@ describe Chef::Resource::Deploy do def resource_has_a_string_attribute(attr_name) it "has a String attribute for #{attr_name.to_s}" do @resource.send(attr_name, "this is a string") - @resource.send(attr_name).should eql("this is a string") - lambda {@resource.send(attr_name, 8675309)}.should raise_error(ArgumentError) + expect(@resource.send(attr_name)).to eql("this is a string") + expect {@resource.send(attr_name, 8675309)}.to raise_error(ArgumentError) end end def resource_has_a_boolean_attribute(attr_name, opts={:defaults_to=>false}) it "has a Boolean attribute for #{attr_name.to_s}" do - @resource.send(attr_name).should eql(opts[:defaults_to]) + expect(@resource.send(attr_name)).to eql(opts[:defaults_to]) @resource.send(attr_name, !opts[:defaults_to]) - @resource.send(attr_name).should eql( !opts[:defaults_to] ) + expect(@resource.send(attr_name)).to eql( !opts[:defaults_to] ) end end def resource_has_a_callback_attribute(attr_name) it "has a Callback attribute #{attr_name}" do callback_block = lambda { :noop } - lambda {@resource.send(attr_name, &callback_block)}.should_not raise_error - @resource.send(attr_name).should == callback_block + expect {@resource.send(attr_name, &callback_block)}.not_to raise_error + expect(@resource.send(attr_name)).to eq(callback_block) callback_file = "path/to/callback.rb" - lambda {@resource.send(attr_name, callback_file)}.should_not raise_error - @resource.send(attr_name).should == callback_file - lambda {@resource.send(attr_name, :this_is_fail)}.should raise_error(ArgumentError) + expect {@resource.send(attr_name, callback_file)}.not_to raise_error + expect(@resource.send(attr_name)).to eq(callback_file) + expect {@resource.send(attr_name, :this_is_fail)}.to raise_error(ArgumentError) end end end @@ -85,7 +85,7 @@ describe Chef::Resource::Deploy do resource_has_a_boolean_attribute(:shallow_clone, :defaults_to=>false) it "uses the first argument as the deploy directory" do - @resource.deploy_to.should eql("/my/deploy/dir") + expect(@resource.deploy_to).to eql("/my/deploy/dir") end # For git, any revision, branch, tag, whatever is resolved to a SHA1 ref. @@ -93,100 +93,100 @@ describe Chef::Resource::Deploy do # Therefore, revision and branch ARE NOT SEPARATE THINGS it "aliases #revision as #branch" do @resource.branch "stable" - @resource.revision.should eql("stable") + expect(@resource.revision).to eql("stable") end it "takes the SCM resource to use as a constant, and defaults to git" do - @resource.scm_provider.should eql(Chef::Provider::Git) + expect(@resource.scm_provider).to eql(Chef::Provider::Git) @resource.scm_provider Chef::Provider::Subversion - @resource.scm_provider.should eql(Chef::Provider::Subversion) + expect(@resource.scm_provider).to eql(Chef::Provider::Subversion) end it "allows scm providers to be set via symbol" do - @resource.scm_provider.should == Chef::Provider::Git + expect(@resource.scm_provider).to eq(Chef::Provider::Git) @resource.scm_provider :subversion - @resource.scm_provider.should == Chef::Provider::Subversion + expect(@resource.scm_provider).to eq(Chef::Provider::Subversion) end it "allows scm providers to be set via string" do - @resource.scm_provider.should == Chef::Provider::Git + expect(@resource.scm_provider).to eq(Chef::Provider::Git) @resource.scm_provider "subversion" - @resource.scm_provider.should == Chef::Provider::Subversion + expect(@resource.scm_provider).to eq(Chef::Provider::Subversion) end it "has a boolean attribute for svn_force_export defaulting to false" do - @resource.svn_force_export.should be_false + expect(@resource.svn_force_export).to be_false @resource.svn_force_export true - @resource.svn_force_export.should be_true - lambda {@resource.svn_force_export(10053)}.should raise_error(ArgumentError) + expect(@resource.svn_force_export).to be_true + expect {@resource.svn_force_export(10053)}.to raise_error(ArgumentError) end it "takes arbitrary environment variables in a hash" do @resource.environment "RAILS_ENV" => "production" - @resource.environment.should == {"RAILS_ENV" => "production"} + expect(@resource.environment).to eq({"RAILS_ENV" => "production"}) end it "takes string arguments to environment for backwards compat, setting RAILS_ENV, RACK_ENV, and MERB_ENV" do @resource.environment "production" - @resource.environment.should == {"RAILS_ENV"=>"production", "RACK_ENV"=>"production","MERB_ENV"=>"production"} + expect(@resource.environment).to eq({"RAILS_ENV"=>"production", "RACK_ENV"=>"production","MERB_ENV"=>"production"}) end it "sets destination to $deploy_to/shared/$repository_cache" do - @resource.destination.should eql("/my/deploy/dir/shared/cached-copy") + expect(@resource.destination).to eql("/my/deploy/dir/shared/cached-copy") end it "sets shared_path to $deploy_to/shared" do - @resource.shared_path.should eql("/my/deploy/dir/shared") + expect(@resource.shared_path).to eql("/my/deploy/dir/shared") end it "sets current_path to $deploy_to/current" do - @resource.current_path.should eql("/my/deploy/dir/current") + expect(@resource.current_path).to eql("/my/deploy/dir/current") end it "gets the current_path correct even if the shared_path is set (regression test)" do @resource.shared_path - @resource.current_path.should eql("/my/deploy/dir/current") + expect(@resource.current_path).to eql("/my/deploy/dir/current") end it "gives #depth as 5 if shallow clone is true, nil otherwise" do - @resource.depth.should be_nil + expect(@resource.depth).to be_nil @resource.shallow_clone true - @resource.depth.should eql("5") + expect(@resource.depth).to eql("5") end it "aliases repo as repository" do @resource.repository "git@github.com/opcode/cookbooks.git" - @resource.repo.should eql("git@github.com/opcode/cookbooks.git") + expect(@resource.repo).to eql("git@github.com/opcode/cookbooks.git") end it "aliases git_ssh_wrapper as ssh_wrapper" do @resource.ssh_wrapper "git_my_repo.sh" - @resource.git_ssh_wrapper.should eql("git_my_repo.sh") + expect(@resource.git_ssh_wrapper).to eql("git_my_repo.sh") end it "has an Array attribute purge_before_symlink, default: log, tmp/pids, public/system" do - @resource.purge_before_symlink.should == %w{ log tmp/pids public/system } + expect(@resource.purge_before_symlink).to eq(%w{ log tmp/pids public/system }) @resource.purge_before_symlink %w{foo bar baz} - @resource.purge_before_symlink.should == %w{foo bar baz} + expect(@resource.purge_before_symlink).to eq(%w{foo bar baz}) end it "has an Array attribute create_dirs_before_symlink, default: tmp, public, config" do - @resource.create_dirs_before_symlink.should == %w{tmp public config} + expect(@resource.create_dirs_before_symlink).to eq(%w{tmp public config}) @resource.create_dirs_before_symlink %w{foo bar baz} - @resource.create_dirs_before_symlink.should == %w{foo bar baz} + expect(@resource.create_dirs_before_symlink).to eq(%w{foo bar baz}) end it 'has a Hash attribute symlinks, default: {"system" => "public/system", "pids" => "tmp/pids", "log" => "log"}' do default = { "system" => "public/system", "pids" => "tmp/pids", "log" => "log"} - @resource.symlinks.should == default + expect(@resource.symlinks).to eq(default) @resource.symlinks "foo" => "bar/baz" - @resource.symlinks.should == {"foo" => "bar/baz"} + expect(@resource.symlinks).to eq({"foo" => "bar/baz"}) end it 'has a Hash attribute symlink_before_migrate, default "config/database.yml" => "config/database.yml"' do - @resource.symlink_before_migrate.should == {"config/database.yml" => "config/database.yml"} + expect(@resource.symlink_before_migrate).to eq({"config/database.yml" => "config/database.yml"}) @resource.symlink_before_migrate "wtf?" => "wtf is going on" - @resource.symlink_before_migrate.should == {"wtf?" => "wtf is going on"} + expect(@resource.symlink_before_migrate).to eq({"wtf?" => "wtf is going on"}) end resource_has_a_callback_attribute :before_migrate @@ -196,55 +196,55 @@ describe Chef::Resource::Deploy do it "aliases restart_command as restart" do @resource.restart "foobaz" - @resource.restart_command.should == "foobaz" + expect(@resource.restart_command).to eq("foobaz") end it "takes a block for the restart parameter" do restart_like_this = lambda {p :noop} @resource.restart(&restart_like_this) - @resource.restart.should == restart_like_this + expect(@resource.restart).to eq(restart_like_this) end it "allows providers to be set with a full class name" do @resource.provider Chef::Provider::Deploy::Timestamped - @resource.provider.should == Chef::Provider::Deploy::Timestamped + expect(@resource.provider).to eq(Chef::Provider::Deploy::Timestamped) end it "allows deploy providers to be set via symbol" do @resource.provider :revision - @resource.provider.should == Chef::Provider::Deploy::Revision + expect(@resource.provider).to eq(Chef::Provider::Deploy::Revision) end it "allows deploy providers to be set via string" do @resource.provider "revision" - @resource.provider.should == Chef::Provider::Deploy::Revision + expect(@resource.provider).to eq(Chef::Provider::Deploy::Revision) end it "defaults keep_releases to 5" do - @resource.keep_releases.should == 5 + expect(@resource.keep_releases).to eq(5) end it "allows keep_releases to be set via integer" do @resource.keep_releases 10 - @resource.keep_releases.should == 10 + expect(@resource.keep_releases).to eq(10) end it "enforces a minimum keep_releases of 1" do @resource.keep_releases 0 - @resource.keep_releases.should == 1 + expect(@resource.keep_releases).to eq(1) end describe "when it has a timeout attribute" do let(:ten_seconds) { 10 } before { @resource.timeout(ten_seconds) } it "stores this timeout" do - @resource.timeout.should == 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 - @resource.timeout.should be_nil + expect(@resource.timeout).to be_nil end end @@ -266,12 +266,12 @@ describe Chef::Resource::Deploy do it "describes its state" do state = @resource.state - state[:deploy_to].should == "/" - state[:revision].should == "1.2.3" + expect(state[:deploy_to]).to eq("/") + expect(state[:revision]).to eq("1.2.3") end it "returns the repository URI as its identity" do - @resource.identity.should == "http://uri.org" + expect(@resource.identity).to eq("http://uri.org") end end diff --git a/spec/unit/resource/directory_spec.rb b/spec/unit/resource/directory_spec.rb index a42383c49e..c452b2a914 100644 --- a/spec/unit/resource/directory_spec.rb +++ b/spec/unit/resource/directory_spec.rb @@ -26,38 +26,38 @@ describe Chef::Resource::Directory do end it "should create a new Chef::Resource::Directory" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Directory) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::Directory) 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 it "should accept create or delete for action" do - lambda { @resource.action :create }.should_not raise_error - lambda { @resource.action :delete }.should_not raise_error - lambda { @resource.action :blues }.should raise_error(ArgumentError) + expect { @resource.action :create }.not_to raise_error + expect { @resource.action :delete }.not_to raise_error + expect { @resource.action :blues }.to raise_error(ArgumentError) end it "should use the object name as the path by default" do - @resource.path.should eql("fakey_fakerton") + expect(@resource.path).to eql("fakey_fakerton") end it "should accept a string as the path" do - lambda { @resource.path "/tmp" }.should_not raise_error - @resource.path.should eql("/tmp") - lambda { @resource.path Hash.new }.should raise_error(ArgumentError) + expect { @resource.path "/tmp" }.not_to raise_error + expect(@resource.path).to eql("/tmp") + expect { @resource.path Hash.new }.to raise_error(ArgumentError) end it "should allow you to have specify whether the action is recursive with true/false" do - lambda { @resource.recursive true }.should_not raise_error - lambda { @resource.recursive false }.should_not raise_error - lambda { @resource.recursive "monkey" }.should raise_error(ArgumentError) + expect { @resource.recursive true }.not_to raise_error + expect { @resource.recursive false }.not_to raise_error + expect { @resource.recursive "monkey" }.to raise_error(ArgumentError) end describe "when it has group, mode, and owner" do @@ -70,13 +70,13 @@ describe Chef::Resource::Directory do it "describes its state" do state = @resource.state - state[:group].should == "wheel" - state[:mode].should == "0664" - state[:owner].should == "root" + expect(state[:group]).to eq("wheel") + expect(state[:mode]).to eq("0664") + expect(state[:owner]).to eq("root") end it "returns the directory path as its identity" do - @resource.identity.should == "/tmp/foo/bar/" + expect(@resource.identity).to eq("/tmp/foo/bar/") end end end diff --git a/spec/unit/resource/easy_install_package_spec.rb b/spec/unit/resource/easy_install_package_spec.rb index d3a5f4a0fe..c68b026b39 100644 --- a/spec/unit/resource/easy_install_package_spec.rb +++ b/spec/unit/resource/easy_install_package_spec.rb @@ -34,6 +34,6 @@ describe Chef::Resource::EasyInstallPackage, "initialize" do it "should allow you to set the easy_install_binary attribute" do @resource.easy_install_binary "/opt/local/bin/easy_install" - @resource.easy_install_binary.should eql("/opt/local/bin/easy_install") + expect(@resource.easy_install_binary).to eql("/opt/local/bin/easy_install") end end diff --git a/spec/unit/resource/env_spec.rb b/spec/unit/resource/env_spec.rb index a1f599400b..566827a27e 100644 --- a/spec/unit/resource/env_spec.rb +++ b/spec/unit/resource/env_spec.rb @@ -26,43 +26,43 @@ describe Chef::Resource::Env do end it "should create a new Chef::Resource::Env" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Env) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::Env) end it "should have a name" do - @resource.name.should eql("FOO") + expect(@resource.name).to eql("FOO") 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, :modify => false, :flibber => 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 key_name by default" do - @resource.key_name.should eql("FOO") + expect(@resource.key_name).to eql("FOO") end it "should accept a string as the env value via 'value'" do - lambda { @resource.value "bar" }.should_not raise_error + expect { @resource.value "bar" }.not_to raise_error end it "should not accept a Hash for the env value via 'to'" do - lambda { @resource.value Hash.new }.should raise_error(ArgumentError) + expect { @resource.value Hash.new }.to raise_error(ArgumentError) end it "should allow you to set an env value via 'to'" do @resource.value "bar" - @resource.value.should eql("bar") + expect(@resource.value).to eql("bar") end describe "when it has key name and value" do @@ -74,11 +74,11 @@ describe Chef::Resource::Env do it "describes its state" do state = @resource.state - state[:value].should == "level7" + expect(state[:value]).to eq("level7") end it "returns the key name as its identity" do - @resource.identity.should == "charmander" + expect(@resource.identity).to eq("charmander") end end diff --git a/spec/unit/resource/erl_call_spec.rb b/spec/unit/resource/erl_call_spec.rb index 3efbdca9a0..8ec182665f 100644 --- a/spec/unit/resource/erl_call_spec.rb +++ b/spec/unit/resource/erl_call_spec.rb @@ -26,45 +26,45 @@ describe Chef::Resource::ErlCall do end it "should create a new Chef::Resource::ErlCall" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::ErlCall) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::ErlCall) end it "should have a resource name of :erl_call" do - @resource.resource_name.should eql(:erl_call) + expect(@resource.resource_name).to eql(:erl_call) end it "should have a default action of run" do - @resource.action.should eql("run") + expect(@resource.action).to eql("run") end it "should accept run as an action" do - lambda { @resource.action :run }.should_not raise_error + expect { @resource.action :run }.not_to raise_error end it "should allow you to set the code attribute" do @resource.code "q()." - @resource.code.should eql("q().") + expect(@resource.code).to eql("q().") end it "should allow you to set the cookie attribute" do @resource.cookie "nomnomnom" - @resource.cookie.should eql("nomnomnom") + expect(@resource.cookie).to eql("nomnomnom") end it "should allow you to set the distributed attribute" do @resource.distributed true - @resource.distributed.should eql(true) + expect(@resource.distributed).to eql(true) end it "should allow you to set the name_type attribute" do @resource.name_type "sname" - @resource.name_type.should eql("sname") + expect(@resource.name_type).to eql("sname") end it "should allow you to set the node_name attribute" do @resource.node_name "chef@erlang" - @resource.node_name.should eql("chef@erlang") + expect(@resource.node_name).to eql("chef@erlang") end describe "when it has cookie and node_name" do @@ -75,7 +75,7 @@ describe Chef::Resource::ErlCall do end it "returns the code as its identity" do - @resource.identity.should == "erl-call:function()" + expect(@resource.identity).to eq("erl-call:function()") end end end diff --git a/spec/unit/resource/execute_spec.rb b/spec/unit/resource/execute_spec.rb index e1728b7892..70b9d87d4c 100644 --- a/spec/unit/resource/execute_spec.rb +++ b/spec/unit/resource/execute_spec.rb @@ -25,7 +25,7 @@ describe Chef::Resource::Execute do it_behaves_like "an execute resource" it "default guard interpreter should be :execute interpreter" do - execute_resource.guard_interpreter.should be(:execute) + expect(execute_resource.guard_interpreter).to be(:execute) end end diff --git a/spec/unit/resource/file_spec.rb b/spec/unit/resource/file_spec.rb index 9c6365f6d3..cfa7511673 100644 --- a/spec/unit/resource/file_spec.rb +++ b/spec/unit/resource/file_spec.rb @@ -25,55 +25,55 @@ describe Chef::Resource::File do 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 it "should have a default content of nil" do - @resource.content.should be_nil + expect(@resource.content).to be_nil end it "should be set to back up 5 files by default" do - @resource.backup.should eql(5) + expect(@resource.backup).to eql(5) end it "should only accept strings for content" do - lambda { @resource.content 5 }.should raise_error(ArgumentError) - lambda { @resource.content :foo }.should raise_error(ArgumentError) - lambda { @resource.content "hello" => "there" }.should raise_error(ArgumentError) - lambda { @resource.content "hi" }.should_not raise_error + expect { @resource.content 5 }.to raise_error(ArgumentError) + expect { @resource.content :foo }.to raise_error(ArgumentError) + expect { @resource.content "hello" => "there" }.to raise_error(ArgumentError) + expect { @resource.content "hi" }.not_to raise_error end it "should only accept false or a number for backup" do - lambda { @resource.backup true }.should raise_error(ArgumentError) - lambda { @resource.backup false }.should_not raise_error - lambda { @resource.backup 10 }.should_not raise_error - lambda { @resource.backup "blues" }.should raise_error(ArgumentError) + expect { @resource.backup true }.to raise_error(ArgumentError) + expect { @resource.backup false }.not_to raise_error + expect { @resource.backup 10 }.not_to raise_error + expect { @resource.backup "blues" }.to raise_error(ArgumentError) end it "should accept a sha256 for checksum" do - lambda { @resource.checksum "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa" }.should_not raise_error - lambda { @resource.checksum "monkey!" }.should raise_error(ArgumentError) + expect { @resource.checksum "0fd012fdc96e96f8f7cf2046522a54aed0ce470224513e45da6bc1a17a4924aa" }.not_to raise_error + expect { @resource.checksum "monkey!" }.to raise_error(ArgumentError) end it "should accept create, delete or touch for action" do - lambda { @resource.action :create }.should_not raise_error - lambda { @resource.action :delete }.should_not raise_error - lambda { @resource.action :touch }.should_not raise_error - lambda { @resource.action :blues }.should raise_error(ArgumentError) + expect { @resource.action :create }.not_to raise_error + expect { @resource.action :delete }.not_to raise_error + expect { @resource.action :touch }.not_to raise_error + expect { @resource.action :blues }.to raise_error(ArgumentError) end it "should use the object name as the path by default" do - @resource.path.should eql("fakey_fakerton") + expect(@resource.path).to eql("fakey_fakerton") end it "should accept a string as the path" do - lambda { @resource.path "/tmp" }.should_not raise_error - @resource.path.should eql("/tmp") - lambda { @resource.path Hash.new }.should raise_error(ArgumentError) + expect { @resource.path "/tmp" }.not_to raise_error + expect(@resource.path).to eql("/tmp") + expect { @resource.path Hash.new }.to raise_error(ArgumentError) end describe "when it has a path, owner, group, mode, and checksum" do @@ -88,15 +88,15 @@ describe Chef::Resource::File do context "on unix", :unix_only do it "describes its state" do state = @resource.state - state[:owner].should == "root" - state[:group].should == "wheel" - state[:mode].should == "0644" - state[:checksum].should == "1" * 64 + expect(state[:owner]).to eq("root") + expect(state[:group]).to eq("wheel") + expect(state[:mode]).to eq("0644") + expect(state[:checksum]).to eq("1" * 64) end end it "returns the file path as its identity" do - @resource.identity.should == "/tmp/foo.txt" + expect(@resource.identity).to eq("/tmp/foo.txt") end end @@ -108,8 +108,8 @@ describe Chef::Resource::File do end it "describes its state including windows ACL attributes" do state = @resource.state - state[:rights].should == [ {:permissions => :read, :principals => "Everyone"}, - {:permissions => :full_control, :principals => "DOMAIN\User"} ] + expect(state[:rights]).to eq([ {:permissions => :read, :principals => "Everyone"}, + {:permissions => :full_control, :principals => "DOMAIN\User"} ]) end end diff --git a/spec/unit/resource/freebsd_package_spec.rb b/spec/unit/resource/freebsd_package_spec.rb index 04a6962270..7263d3a7ba 100644 --- a/spec/unit/resource/freebsd_package_spec.rb +++ b/spec/unit/resource/freebsd_package_spec.rb @@ -32,15 +32,15 @@ describe Chef::Resource::FreebsdPackage do describe "Initialization" do it "should return a Chef::Resource::FreebsdPackage" do - @resource.should be_a_kind_of(Chef::Resource::FreebsdPackage) + expect(@resource).to be_a_kind_of(Chef::Resource::FreebsdPackage) end it "should set the resource_name to :freebsd_package" do - @resource.resource_name.should eql(:freebsd_package) + expect(@resource.resource_name).to eql(:freebsd_package) end it "should not set the provider" do - @resource.provider.should be_nil + expect(@resource.provider).to be_nil end end @@ -50,7 +50,7 @@ describe Chef::Resource::FreebsdPackage do it "should be Freebsd::Port" do @resource.source('ports') @resource.after_created - @resource.provider.should == Chef::Provider::Package::Freebsd::Port + expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Port) end end @@ -59,7 +59,7 @@ describe Chef::Resource::FreebsdPackage do [1000017, 1000018, 1000500, 1001001, 1100000].each do |__freebsd_version| @node.automatic_attrs[:os_version] = __freebsd_version @resource.after_created - @resource.provider.should == Chef::Provider::Package::Freebsd::Pkgng + expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkgng) end end end @@ -67,21 +67,21 @@ describe Chef::Resource::FreebsdPackage do describe "if pkgng enabled" do it "should be Freebsd::Pkgng" do pkg_enabled = OpenStruct.new(:stdout => "yes\n") - @resource.stub(:shell_out!).with("make -V WITH_PKGNG", :env => nil).and_return(pkg_enabled) + allow(@resource).to receive(:shell_out!).with("make -V WITH_PKGNG", :env => nil).and_return(pkg_enabled) @resource.after_created - @resource.provider.should == Chef::Provider::Package::Freebsd::Pkgng + expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkgng) end end describe "if __Freebsd_version is less than 1000017 and pkgng not enabled" do it "should be Freebsd::Pkg" do pkg_enabled = OpenStruct.new(:stdout => "\n") - @resource.stub(:shell_out!).with("make -V WITH_PKGNG", :env => nil).and_return(pkg_enabled) + allow(@resource).to receive(:shell_out!).with("make -V WITH_PKGNG", :env => nil).and_return(pkg_enabled) [1000016, 1000000, 901503, 902506, 802511].each do |__freebsd_version| @node.automatic_attrs[:os_version] = __freebsd_version @resource.after_created - @resource.provider.should == Chef::Provider::Package::Freebsd::Pkg + expect(@resource.provider).to eq(Chef::Provider::Package::Freebsd::Pkg) end end end diff --git a/spec/unit/resource/gem_package_spec.rb b/spec/unit/resource/gem_package_spec.rb index 01c4fb6106..0f3eae70bb 100644 --- a/spec/unit/resource/gem_package_spec.rb +++ b/spec/unit/resource/gem_package_spec.rb @@ -37,6 +37,6 @@ describe Chef::Resource::GemPackage, "gem_binary" do it "should set the gem_binary variable to whatever is passed in" do @resource.gem_binary("/opt/local/bin/gem") - @resource.gem_binary.should eql("/opt/local/bin/gem") + expect(@resource.gem_binary).to eql("/opt/local/bin/gem") end end diff --git a/spec/unit/resource/git_spec.rb b/spec/unit/resource/git_spec.rb index da7aee1014..6a39b3d172 100644 --- a/spec/unit/resource/git_spec.rb +++ b/spec/unit/resource/git_spec.rb @@ -33,18 +33,18 @@ describe Chef::Resource::Git do end it "is a kind of Scm Resource" do - @git.should be_a_kind_of(Chef::Resource::Scm) - @git.should be_an_instance_of(Chef::Resource::Git) + expect(@git).to be_a_kind_of(Chef::Resource::Scm) + expect(@git).to be_an_instance_of(Chef::Resource::Git) end it "uses aliases revision as branch" do @git.branch "HEAD" - @git.revision.should eql("HEAD") + expect(@git.revision).to eql("HEAD") end it "aliases revision as reference" do @git.reference "v1.0 tag" - @git.revision.should eql("v1.0 tag") + expect(@git.revision).to eql("v1.0 tag") end end diff --git a/spec/unit/resource/group_spec.rb b/spec/unit/resource/group_spec.rb index 0c3cf4f67f..bcf9205f7e 100644 --- a/spec/unit/resource/group_spec.rb +++ b/spec/unit/resource/group_spec.rb @@ -25,47 +25,47 @@ describe Chef::Resource::Group, "initialize" do end it "should create a new Chef::Resource::Group" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Group) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::Group) end it "should set the resource_name to :group" do - @resource.resource_name.should eql(:group) + expect(@resource.resource_name).to eql(:group) end it "should set the group_name equal to the argument to initialize" do - @resource.group_name.should eql("admin") + expect(@resource.group_name).to eql("admin") end it "should default gid to nil" do - @resource.gid.should eql(nil) + expect(@resource.gid).to eql(nil) end it "should default members to an empty array" do - @resource.members.should eql([]) + expect(@resource.members).to eql([]) end it "should alias users to members, also an empty array" do - @resource.users.should eql([]) + expect(@resource.users).to eql([]) end it "should set action to :create" do - @resource.action.should eql(:create) + expect(@resource.action).to eql(:create) end %w{create remove modify manage}.each do |action| it "should allow action #{action}" do - @resource.allowed_actions.detect { |a| a == action.to_sym }.should eql(action.to_sym) + expect(@resource.allowed_actions.detect { |a| a == action.to_sym }).to eql(action.to_sym) end end it "should accept domain groups (@ or \ separator) on non-windows" do - lambda { @resource.group_name "domain\@group" }.should_not raise_error - @resource.group_name.should == "domain\@group" - lambda { @resource.group_name "domain\\group" }.should_not raise_error - @resource.group_name.should == "domain\\group" - lambda { @resource.group_name "domain\\group^name" }.should_not raise_error - @resource.group_name.should == "domain\\group^name" + expect { @resource.group_name "domain\@group" }.not_to raise_error + expect(@resource.group_name).to eq("domain\@group") + expect { @resource.group_name "domain\\group" }.not_to raise_error + expect(@resource.group_name).to eq("domain\\group") + expect { @resource.group_name "domain\\group^name" }.not_to raise_error + expect(@resource.group_name).to eq("domain\\group^name") end end @@ -76,11 +76,11 @@ describe Chef::Resource::Group, "group_name" do it "should allow a string" do @resource.group_name "pirates" - @resource.group_name.should eql("pirates") + expect(@resource.group_name).to eql("pirates") end it "should not allow a hash" do - lambda { @resource.send(:group_name, { :aj => "is freakin awesome" }) }.should raise_error(ArgumentError) + expect { @resource.send(:group_name, { :aj => "is freakin awesome" }) }.to raise_error(ArgumentError) end end @@ -91,11 +91,11 @@ describe Chef::Resource::Group, "gid" do it "should allow an integer" do @resource.gid 100 - @resource.gid.should eql(100) + expect(@resource.gid).to eql(100) end it "should not allow a hash" do - lambda { @resource.send(:gid, { :aj => "is freakin awesome" }) }.should raise_error(ArgumentError) + expect { @resource.send(:gid, { :aj => "is freakin awesome" }) }.to raise_error(ArgumentError) end end @@ -107,16 +107,16 @@ describe Chef::Resource::Group, "members" do [ :users, :members].each do |method| it "(#{method}) should allow and convert a string" do @resource.send(method, "aj") - @resource.send(method).should eql(["aj"]) + expect(@resource.send(method)).to eql(["aj"]) end it "(#{method}) should allow an array" do @resource.send(method, [ "aj", "adam" ]) - @resource.send(method).should eql( ["aj", "adam"] ) + expect(@resource.send(method)).to eql( ["aj", "adam"] ) end it "(#{method}) should not allow a hash" do - lambda { @resource.send(method, { :aj => "is freakin awesome" }) }.should raise_error(ArgumentError) + expect { @resource.send(method, { :aj => "is freakin awesome" }) }.to raise_error(ArgumentError) end end end @@ -127,16 +127,16 @@ describe Chef::Resource::Group, "append" do end it "should default to false" do - @resource.append.should eql(false) + expect(@resource.append).to eql(false) end it "should allow a boolean" do @resource.append true - @resource.append.should eql(true) + expect(@resource.append).to eql(true) end it "should not allow a hash" do - lambda { @resource.send(:gid, { :aj => "is freakin awesome" }) }.should raise_error(ArgumentError) + expect { @resource.send(:gid, { :aj => "is freakin awesome" }) }.to raise_error(ArgumentError) end describe "when it has members" do @@ -147,11 +147,11 @@ describe Chef::Resource::Group, "append" do it "describes its state" do state = @resource.state - state[:members].should eql(["blastoise", "pikachu"]) + expect(state[:members]).to eql(["blastoise", "pikachu"]) end it "returns the group name as its identity" do - @resource.identity.should == "pokemon" + expect(@resource.identity).to eq("pokemon") end end end diff --git a/spec/unit/resource/http_request_spec.rb b/spec/unit/resource/http_request_spec.rb index b636ca9994..aa4ce4dfbc 100644 --- a/spec/unit/resource/http_request_spec.rb +++ b/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 diff --git a/spec/unit/resource/ifconfig_spec.rb b/spec/unit/resource/ifconfig_spec.rb index 10a4d09982..ea5282acd5 100644 --- a/spec/unit/resource/ifconfig_spec.rb +++ b/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 diff --git a/spec/unit/resource/ips_package_spec.rb b/spec/unit/resource/ips_package_spec.rb index 8718c5c093..126ae00224 100644 --- a/spec/unit/resource/ips_package_spec.rb +++ b/spec/unit/resource/ips_package_spec.rb @@ -35,6 +35,6 @@ describe Chef::Resource::IpsPackage, "initialize" do 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 diff --git a/spec/unit/resource/link_spec.rb b/spec/unit/resource/link_spec.rb index 221617f9b3..3573a15f31 100644 --- a/spec/unit/resource/link_spec.rb +++ b/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 diff --git a/spec/unit/resource/log_spec.rb b/spec/unit/resource/log_spec.rb index c0201e57f3..b2af194238 100644 --- a/spec/unit/resource/log_spec.rb +++ b/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 diff --git a/spec/unit/resource/mdadm_spec.rb b/spec/unit/resource/mdadm_spec.rb index daf10bcfea..866309ec5b 100644 --- a/spec/unit/resource/mdadm_spec.rb +++ b/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 diff --git a/spec/unit/resource/mount_spec.rb b/spec/unit/resource/mount_spec.rb index 0a154342c7..ad95c06e04 100644 --- a/spec/unit/resource/mount_spec.rb +++ b/spec/unit/resource/mount_spec.rb @@ -25,150 +25,150 @@ describe Chef::Resource::Mount do end it "should create a new Chef::Resource::Mount" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Mount) + 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 - @resource.name.should eql("filesystem") + expect(@resource.name).to eql("filesystem") end it "should set mount_point to the name" do - @resource.mount_point.should eql("filesystem") + expect(@resource.mount_point).to eql("filesystem") end it "should have a default action of mount" do - @resource.action.should eql(:mount) + expect(@resource.action).to eql(:mount) end it "should accept mount, umount and remount as actions" do - lambda { @resource.action :mount }.should_not raise_error - lambda { @resource.action :umount }.should_not raise_error - lambda { @resource.action :remount }.should_not raise_error - lambda { @resource.action :brooklyn }.should raise_error(ArgumentError) + expect { @resource.action :mount }.not_to raise_error + expect { @resource.action :umount }.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" - @resource.device.should eql("/dev/sdb3") + expect(@resource.device).to eql("/dev/sdb3") end it "should set fsck_device to '-' by default" do - @resource.fsck_device.should eql('-') + expect(@resource.fsck_device).to eql('-') end it "should allow you to set the fsck_device attribute" do @resource.fsck_device "/dev/rdsk/sdb3" - @resource.fsck_device.should eql("/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" - @resource.fstype.should eql("nfs") + expect(@resource.fstype).to eql("nfs") end it "should allow you to set the dump attribute" do @resource.dump 1 - @resource.dump.should eql(1) + expect(@resource.dump).to eql(1) end it "should allow you to set the pass attribute" do @resource.pass 1 - @resource.pass.should eql(1) + expect(@resource.pass).to eql(1) end it "should set the options attribute to defaults" do - @resource.options.should eql(["defaults"]) + 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" - @resource.options.should be_a_kind_of(Array) + expect(@resource.options).to be_a_kind_of(Array) end it "should allow options attribute as an array" do @resource.options ["ro", "nosuid"] - @resource.options.should be_a_kind_of(Array) + 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 {["rw", "noexec"]} - @resource.options.should eql(["rw", "noexec"]) + expect(@resource.options).to eql(["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"} - @resource.options.should be_a_kind_of(Array) - @resource.options.should eql(["rw", "noexec"]) + expect(@resource.options).to be_a_kind_of(Array) + expect(@resource.options).to eql(["rw", "noexec"]) end it "should accept true for mounted" do @resource.mounted(true) - @resource.mounted.should eql(true) + expect(@resource.mounted).to eql(true) end it "should accept false for mounted" do @resource.mounted(false) - @resource.mounted.should eql(false) + expect(@resource.mounted).to eql(false) end it "should set mounted to false by default" do - @resource.mounted.should eql(false) + expect(@resource.mounted).to eql(false) end it "should not accept a string for mounted" do - lambda { @resource.mounted("poop") }.should raise_error(ArgumentError) + expect { @resource.mounted("poop") }.to raise_error(ArgumentError) end it "should accept true for enabled" do @resource.enabled(true) - @resource.enabled.should eql(true) + expect(@resource.enabled).to eql(true) end it "should accept false for enabled" do @resource.enabled(false) - @resource.enabled.should eql(false) + expect(@resource.enabled).to eql(false) end it "should set enabled to false by default" do - @resource.enabled.should eql(false) + expect(@resource.enabled).to eql(false) end it "should not accept a string for enabled" do - lambda { @resource.enabled("poop") }.should raise_error(ArgumentError) + expect { @resource.enabled("poop") }.to raise_error(ArgumentError) end it "should default all feature support to false" do support_hash = { :remount => false } - @resource.supports.should == support_hash + expect(@resource.supports).to eq(support_hash) end it "should allow you to set feature support as an array" do support_array = [ :remount ] support_hash = { :remount => true } @resource.supports(support_array) - @resource.supports.should == support_hash + expect(@resource.supports).to eq(support_hash) end it "should allow you to set feature support as a hash" do support_hash = { :remount => true } @resource.supports(support_hash) - @resource.supports.should == support_hash + expect(@resource.supports).to eq(support_hash) end it "should allow you to set username" do @resource.username("Administrator") - @resource.username.should == "Administrator" + expect(@resource.username).to eq("Administrator") end it "should allow you to set password" do @resource.password("Jetstream123!") - @resource.password.should == "Jetstream123!" + expect(@resource.password).to eq("Jetstream123!") end it "should allow you to set domain" do @resource.domain("TEST_DOMAIN") - @resource.domain.should == "TEST_DOMAIN" + expect(@resource.domain).to eq("TEST_DOMAIN") end describe "when it has mount point, device type, and fstype" do @@ -181,13 +181,13 @@ describe Chef::Resource::Mount do it "describes its state" do state = @resource.state - state[:mount_point].should == "123.456" - state[:device_type].should eql(:device) - state[:fstype].should == "ranked" + 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 - @resource.identity.should == "charmander" + expect(@resource.identity).to eq("charmander") end end @@ -202,12 +202,12 @@ describe Chef::Resource::Mount do it "describes its state" do state = @resource.state - state[:mount_point].should == "T:" - state[:username].should == "Administrator" - state[:password].should == "Jetstream123!" - state[:domain].should == "TEST_DOMAIN" - state[:device_type].should eql(:device) - state[:fstype].should == "auto" + expect(state[:mount_point]).to eq("T:") + expect(state[:username]).to eq("Administrator") + expect(state[:password]).to eq("Jetstream123!") + expect(state[:domain]).to eq("TEST_DOMAIN") + expect(state[:device_type]).to eql(:device) + expect(state[:fstype]).to eq("auto") end end diff --git a/spec/unit/resource/ohai_spec.rb b/spec/unit/resource/ohai_spec.rb index b8d062b4c9..fe29755abf 100644 --- a/spec/unit/resource/ohai_spec.rb +++ b/spec/unit/resource/ohai_spec.rb @@ -25,21 +25,21 @@ describe Chef::Resource::Ohai do end it "should create a new Chef::Resource::Ohai" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Ohai) + 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 - @resource.resource_name.should eql(:ohai) + expect(@resource.resource_name).to eql(:ohai) end it "should have a default action of create" do - @resource.action.should eql(:reload) + expect(@resource.action).to eql(:reload) end it "should allow you to set the plugin attribute" do @resource.plugin "passwd" - @resource.plugin.should eql("passwd") + expect(@resource.plugin).to eql("passwd") end describe "when it has a plugin value" do @@ -50,11 +50,11 @@ describe Chef::Resource::Ohai do it "describes its state" do state = @resource.state - state[:plugin].should == "passwd" + expect(state[:plugin]).to eq("passwd") end it "returns the name as its identity" do - @resource.identity.should == "test" + expect(@resource.identity).to eq("test") end end diff --git a/spec/unit/resource/package_spec.rb b/spec/unit/resource/package_spec.rb index 8a1a13394e..449732a3c4 100644 --- a/spec/unit/resource/package_spec.rb +++ b/spec/unit/resource/package_spec.rb @@ -26,42 +26,42 @@ describe Chef::Resource::Package do end it "should create a new Chef::Resource::Package" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Package) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::Package) end it "should set the package_name to the first argument to new" do - @resource.package_name.should eql("emacs") + expect(@resource.package_name).to eql("emacs") end it "should accept a string for the package name" do @resource.package_name "something" - @resource.package_name.should eql("something") + expect(@resource.package_name).to eql("something") end it "should accept a string for the version" do @resource.version "something" - @resource.version.should eql("something") + expect(@resource.version).to eql("something") end it "should accept a string for the response file" do @resource.response_file "something" - @resource.response_file.should eql("something") + expect(@resource.response_file).to eql("something") end it "should accept a hash for response file template variables" do @resource.response_file_variables({:variables => true}) - @resource.response_file_variables.should eql({:variables => true}) + expect(@resource.response_file_variables).to eql({:variables => true}) end it "should accept a string for the source" do @resource.source "something" - @resource.source.should eql("something") + expect(@resource.source).to eql("something") end it "should accept a string for the options" do @resource.options "something" - @resource.options.should eql("something") + expect(@resource.options).to eql("something") end describe "when it has a package_name and version" do @@ -73,12 +73,12 @@ describe Chef::Resource::Package do it "describes its state" do state = @resource.state - state[:version].should == "10.9.8" - state[:options].should == "-al" + expect(state[:version]).to eq("10.9.8") + expect(state[:options]).to eq("-al") end it "returns the file path as its identity" do - @resource.identity.should == "tomcat" + expect(@resource.identity).to eq("tomcat") end end diff --git a/spec/unit/resource/perl_spec.rb b/spec/unit/resource/perl_spec.rb index d25dc98563..7247cce6e3 100644 --- a/spec/unit/resource/perl_spec.rb +++ b/spec/unit/resource/perl_spec.rb @@ -25,16 +25,16 @@ describe Chef::Resource::Perl do end it "should create a new Chef::Resource::Perl" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Perl) + 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 - @resource.resource_name.should eql(:perl) + expect(@resource.resource_name).to eql(:perl) end it "should have an interpreter of perl" do - @resource.interpreter.should eql("perl") + expect(@resource.interpreter).to eql("perl") end end diff --git a/spec/unit/resource/portage_package_spec.rb b/spec/unit/resource/portage_package_spec.rb index 510f3b5864..d2ac7ac4be 100644 --- a/spec/unit/resource/portage_package_spec.rb +++ b/spec/unit/resource/portage_package_spec.rb @@ -25,14 +25,14 @@ describe Chef::Resource::PortagePackage, "initialize" do end it "should return a Chef::Resource::PortagePackage" do - @resource.should be_a_kind_of(Chef::Resource::PortagePackage) + expect(@resource).to be_a_kind_of(Chef::Resource::PortagePackage) end it "should set the resource_name to :portage_package" do - @resource.resource_name.should eql(:portage_package) + expect(@resource.resource_name).to eql(:portage_package) end it "should set the provider to Chef::Provider::Package::Portage" do - @resource.provider.should eql(Chef::Provider::Package::Portage) + expect(@resource.provider).to eql(Chef::Provider::Package::Portage) end end diff --git a/spec/unit/resource/powershell_spec.rb b/spec/unit/resource/powershell_spec.rb index da20c4f0bf..c263172ae6 100644 --- a/spec/unit/resource/powershell_spec.rb +++ b/spec/unit/resource/powershell_spec.rb @@ -33,32 +33,32 @@ describe Chef::Resource::PowershellScript do end it "should create a new Chef::Resource::PowershellScript" do - @resource.should be_a_kind_of(Chef::Resource::PowershellScript) + expect(@resource).to be_a_kind_of(Chef::Resource::PowershellScript) end it "should set convert_boolean_return to false by default" do - @resource.convert_boolean_return.should == false + expect(@resource.convert_boolean_return).to eq(false) end it "should return the value for convert_boolean_return that was set" do @resource.convert_boolean_return true - @resource.convert_boolean_return.should == true + expect(@resource.convert_boolean_return).to eq(true) @resource.convert_boolean_return false - @resource.convert_boolean_return.should == false + expect(@resource.convert_boolean_return).to eq(false) end context "when using guards" do let(:resource) { @resource } before(:each) do - resource.stub(:run_action) - resource.stub(:updated).and_return(true) + allow(resource).to receive(:run_action) + allow(resource).to receive(:updated).and_return(true) end it "inherits exactly the :cwd, :environment, :group, :path, :user, :umask, and :architecture attributes from a parent resource class" do inherited_difference = Chef::Resource::PowershellScript.guard_inherited_attributes - [:cwd, :environment, :group, :path, :user, :umask, :architecture ] - inherited_difference.should == [] + expect(inherited_difference).to eq([]) end it "should allow guard interpreter to be set to Chef::Resource::Script" do diff --git a/spec/unit/resource/python_spec.rb b/spec/unit/resource/python_spec.rb index 3362b68c62..8a3f7e48ca 100644 --- a/spec/unit/resource/python_spec.rb +++ b/spec/unit/resource/python_spec.rb @@ -25,16 +25,16 @@ describe Chef::Resource::Python do end it "should create a new Chef::Resource::Python" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Python) + 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 - @resource.resource_name.should eql(:python) + expect(@resource.resource_name).to eql(:python) end it "should have an interpreter of python" do - @resource.interpreter.should eql("python") + expect(@resource.interpreter).to eql("python") end end diff --git a/spec/unit/resource/registry_key_spec.rb b/spec/unit/resource/registry_key_spec.rb index 00c301d61d..e2a864d73a 100644 --- a/spec/unit/resource/registry_key_spec.rb +++ b/spec/unit/resource/registry_key_spec.rb @@ -24,33 +24,33 @@ describe Chef::Resource::RegistryKey, "initialize" do end it "should create a new Chef::Resource::RegistryKey" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::RegistryKey) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::RegistryKey) end it "should set the resource_name to :registry_key" do - @resource.resource_name.should eql(:registry_key) + expect(@resource.resource_name).to eql(:registry_key) end it "should set the key equal to the argument to initialize" do - @resource.key.should eql('HKCU\Software\Raxicoricofallapatorius') + expect(@resource.key).to eql('HKCU\Software\Raxicoricofallapatorius') end it "should default recursive to false" do - @resource.recursive.should eql(false) + expect(@resource.recursive).to eql(false) end it "should default architecture to :machine" do - @resource.architecture.should eql(:machine) + expect(@resource.architecture).to eql(:machine) end it "should set action to :create" do - @resource.action.should eql(:create) + expect(@resource.action).to eql(:create) end %w{create create_if_missing delete delete_key}.each do |action| it "should allow action #{action}" do - @resource.allowed_actions.detect { |a| a == action.to_sym }.should eql(action.to_sym) + expect(@resource.allowed_actions.detect { |a| a == action.to_sym }).to eql(action.to_sym) end end end @@ -62,15 +62,15 @@ describe Chef::Resource::RegistryKey, "key" do it "should allow a string" do @resource.key 'HKCU\Software\Poosh' - @resource.key.should eql('HKCU\Software\Poosh') + expect(@resource.key).to eql('HKCU\Software\Poosh') end it "should not allow an integer" do - lambda { @resource.send(:key, 100) }.should raise_error(ArgumentError) + expect { @resource.send(:key, 100) }.to raise_error(ArgumentError) end it "should not allow a hash" do - lambda { @resource.send(:key, { :sonic => "screwdriver" }) }.should raise_error(ArgumentError) + expect { @resource.send(:key, { :sonic => "screwdriver" }) }.to raise_error(ArgumentError) end end @@ -81,41 +81,41 @@ describe Chef::Resource::RegistryKey, "values" do it "should allow a single proper hash of registry values" do @resource.values( { :name => 'poosh', :type => :string, :data => 'carmen' } ) - @resource.values.should eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ]) + expect(@resource.values).to eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ]) end it "should allow an array of proper hashes of registry values" do @resource.values [ { :name => 'poosh', :type => :string, :data => 'carmen' } ] - @resource.values.should eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ]) + expect(@resource.values).to eql([ { :name => 'poosh', :type => :string, :data => 'carmen' } ]) end it "should return checksummed data if the type is unsafe" do @resource.values( { :name => 'poosh', :type => :binary, :data => 255.chr * 1 }) - @resource.values.should eql([ { :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" } ]) + expect(@resource.values).to eql([ { :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" } ]) end it "should throw an exception if the name field is missing" do - lambda { @resource.values [ { :type => :string, :data => 'carmen' } ] }.should raise_error(ArgumentError) + expect { @resource.values [ { :type => :string, :data => 'carmen' } ] }.to raise_error(ArgumentError) end it "should throw an exception if the type field is missing" do - lambda { @resource.values [ { :name => 'poosh', :data => 'carmen' } ] }.should raise_error(ArgumentError) + expect { @resource.values [ { :name => 'poosh', :data => 'carmen' } ] }.to raise_error(ArgumentError) end it "should throw an exception if the data field is missing" do - lambda { @resource.values [ { :name => 'poosh', :type => :string } ] }.should raise_error(ArgumentError) + expect { @resource.values [ { :name => 'poosh', :type => :string } ] }.to raise_error(ArgumentError) end it "should throw an exception if extra fields are present" do - lambda { @resource.values [ { :name => 'poosh', :type => :string, :data => 'carmen', :screwdriver => 'sonic' } ] }.should raise_error(ArgumentError) + expect { @resource.values [ { :name => 'poosh', :type => :string, :data => 'carmen', :screwdriver => 'sonic' } ] }.to raise_error(ArgumentError) end it "should not allow a string" do - lambda { @resource.send(:values, 'souffle') }.should raise_error(ArgumentError) + expect { @resource.send(:values, 'souffle') }.to raise_error(ArgumentError) end it "should not allow an integer" do - lambda { @resource.send(:values, 100) }.should raise_error(ArgumentError) + expect { @resource.send(:values, 100) }.to raise_error(ArgumentError) end end @@ -126,23 +126,23 @@ describe Chef::Resource::RegistryKey, "recursive" do it "should allow a boolean" do @resource.recursive(true) - @resource.recursive.should eql(true) + expect(@resource.recursive).to eql(true) end it "should not allow a hash" do - lambda { @resource.recursive({:sonic => :screwdriver}) }.should raise_error(ArgumentError) + expect { @resource.recursive({:sonic => :screwdriver}) }.to raise_error(ArgumentError) end it "should not allow an array" do - lambda { @resource.recursive([:nose, :chin]) }.should raise_error(ArgumentError) + expect { @resource.recursive([:nose, :chin]) }.to raise_error(ArgumentError) end it "should not allow a string" do - lambda { @resource.recursive('souffle') }.should raise_error(ArgumentError) + expect { @resource.recursive('souffle') }.to raise_error(ArgumentError) end it "should not allow an integer" do - lambda { @resource.recursive(100) }.should raise_error(ArgumentError) + expect { @resource.recursive(100) }.to raise_error(ArgumentError) end end @@ -154,24 +154,24 @@ describe Chef::Resource::RegistryKey, "architecture" do [ :i386, :x86_64, :machine ].each do |arch| it "should allow #{arch} as a symbol" do @resource.architecture(arch) - @resource.architecture.should eql(arch) + expect(@resource.architecture).to eql(arch) end end it "should not allow a hash" do - lambda { @resource.architecture({:sonic => :screwdriver}) }.should raise_error(ArgumentError) + expect { @resource.architecture({:sonic => :screwdriver}) }.to raise_error(ArgumentError) end it "should not allow an array" do - lambda { @resource.architecture([:nose, :chin]) }.should raise_error(ArgumentError) + expect { @resource.architecture([:nose, :chin]) }.to raise_error(ArgumentError) end it "should not allow a string" do - lambda { @resource.architecture('souffle') }.should raise_error(ArgumentError) + expect { @resource.architecture('souffle') }.to raise_error(ArgumentError) end it "should not allow an integer" do - lambda { @resource.architecture(100) }.should raise_error(ArgumentError) + expect { @resource.architecture(100) }.to raise_error(ArgumentError) end end @@ -183,7 +183,7 @@ describe Chef::Resource::RegistryKey, ":unscrubbed_values" do it "should return unsafe data as-is" do key_values = [ { :name => 'poosh', :type => :binary, :data => 255.chr * 1 } ] @resource.values(key_values) - @resource.unscrubbed_values.should eql(key_values) + expect(@resource.unscrubbed_values).to eql(key_values) end end @@ -194,6 +194,6 @@ describe Chef::Resource::RegistryKey, "state" do it "should return scrubbed values" do @resource.values([ { :name => 'poosh', :type => :binary, :data => 255.chr * 1 } ]) - @resource.state.should eql( { :values => [{ :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" }] } ) + expect(@resource.state).to eql( { :values => [{ :name => 'poosh', :type => :binary, :data => "00594fd4f42ba43fc1ca0427a0576295" }] } ) end end diff --git a/spec/unit/resource/remote_directory_spec.rb b/spec/unit/resource/remote_directory_spec.rb index d3800062ae..1ab75586b6 100644 --- a/spec/unit/resource/remote_directory_spec.rb +++ b/spec/unit/resource/remote_directory_spec.rb @@ -25,52 +25,52 @@ describe Chef::Resource::RemoteDirectory do end it "should create a new Chef::Resource::RemoteDirectory" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::RemoteDirectory) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::RemoteDirectory) end it "should set the path to the first argument to new" do - @resource.path.should eql("/etc/dunk") + expect(@resource.path).to eql("/etc/dunk") end it "should accept a string for the remote directory source" do @resource.source "foo" - @resource.source.should eql("foo") + expect(@resource.source).to eql("foo") end it "should have the basename of the remote directory resource as the default source" do - @resource.source.should eql("dunk") + expect(@resource.source).to eql("dunk") end it "should accept a number for the remote files backup" do @resource.files_backup 1 - @resource.files_backup.should eql(1) + expect(@resource.files_backup).to eql(1) end it "should accept false for the remote files backup" do @resource.files_backup false - @resource.files_backup.should eql(false) + expect(@resource.files_backup).to eql(false) end it "should accept 3 or 4 digets for the files_mode" do @resource.files_mode 100 - @resource.files_mode.should eql(100) + expect(@resource.files_mode).to eql(100) @resource.files_mode 1000 - @resource.files_mode.should eql(1000) + expect(@resource.files_mode).to eql(1000) end it "should accept a string or number for the files group" do @resource.files_group "heart" - @resource.files_group.should eql("heart") + expect(@resource.files_group).to eql("heart") @resource.files_group 1000 - @resource.files_group.should eql(1000) + expect(@resource.files_group).to eql(1000) end it "should accept a string or number for the files owner" do @resource.files_owner "heart" - @resource.files_owner.should eql("heart") + expect(@resource.files_owner).to eql("heart") @resource.files_owner 1000 - @resource.files_owner.should eql(1000) + expect(@resource.files_owner).to eql(1000) end describe "when it has cookbook, files owner, files mode, and source" do @@ -85,13 +85,13 @@ describe Chef::Resource::RemoteDirectory do it "describes its state" do state = @resource.state - state[:files_owner].should == "root" - state[:files_group].should == "supergroup" - state[:files_mode].should == "0664" + expect(state[:files_owner]).to eq("root") + expect(state[:files_group]).to eq("supergroup") + expect(state[:files_mode]).to eq("0664") end it "returns the path as its identity" do - @resource.identity.should == "/var/path/" + expect(@resource.identity).to eq("/var/path/") end end end diff --git a/spec/unit/resource/remote_file_spec.rb b/spec/unit/resource/remote_file_spec.rb index 8f1633119d..14d2fb97bc 100644 --- a/spec/unit/resource/remote_file_spec.rb +++ b/spec/unit/resource/remote_file_spec.rb @@ -27,74 +27,74 @@ describe Chef::Resource::RemoteFile do describe "initialize" do it "should create a new Chef::Resource::RemoteFile" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::File) - @resource.should be_a_kind_of(Chef::Resource::RemoteFile) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::File) + expect(@resource).to be_a_kind_of(Chef::Resource::RemoteFile) end end it "says its provider is RemoteFile when the source is an absolute URI" do @resource.source("http://www.google.com/robots.txt") - @resource.provider.should == Chef::Provider::RemoteFile - Chef::Platform.find_provider(:noplatform, 'noversion', @resource).should == Chef::Provider::RemoteFile + expect(@resource.provider).to eq(Chef::Provider::RemoteFile) + expect(Chef::Platform.find_provider(:noplatform, 'noversion', @resource)).to eq(Chef::Provider::RemoteFile) end describe "source" do it "does not have a default value for 'source'" do - @resource.source.should eql([]) + expect(@resource.source).to eql([]) end it "should accept a URI for the remote file source" do @resource.source "http://opscode.com/" - @resource.source.should eql([ "http://opscode.com/" ]) + expect(@resource.source).to eql([ "http://opscode.com/" ]) end it "should accept a delayed evalutator (string) for the remote file source" do @resource.source Chef::DelayedEvaluator.new {"http://opscode.com/"} - @resource.source.should eql([ "http://opscode.com/" ]) + expect(@resource.source).to eql([ "http://opscode.com/" ]) end it "should accept an array of URIs for the remote file source" do @resource.source([ "http://opscode.com/", "http://puppetlabs.com/" ]) - @resource.source.should eql([ "http://opscode.com/", "http://puppetlabs.com/" ]) + expect(@resource.source).to eql([ "http://opscode.com/", "http://puppetlabs.com/" ]) end it "should accept a delated evaluator (array) for the remote file source" do @resource.source Chef::DelayedEvaluator.new { [ "http://opscode.com/", "http://puppetlabs.com/" ] } - @resource.source.should eql([ "http://opscode.com/", "http://puppetlabs.com/" ]) + expect(@resource.source).to eql([ "http://opscode.com/", "http://puppetlabs.com/" ]) end it "should accept an multiple URIs as arguments for the remote file source" do @resource.source("http://opscode.com/", "http://puppetlabs.com/") - @resource.source.should eql([ "http://opscode.com/", "http://puppetlabs.com/" ]) + expect(@resource.source).to eql([ "http://opscode.com/", "http://puppetlabs.com/" ]) end it "should only accept a single argument if a delayed evalutor is used" do - lambda { + expect { @resource.source("http://opscode.com/", Chef::DelayedEvaluator.new {"http://opscode.com/"}) - }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI) + }.to raise_error(Chef::Exceptions::InvalidRemoteFileURI) end it "should only accept a single array item if a delayed evalutor is used" do - lambda { + expect { @resource.source(["http://opscode.com/", Chef::DelayedEvaluator.new {"http://opscode.com/"}]) - }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI) + }.to raise_error(Chef::Exceptions::InvalidRemoteFileURI) end it "does not accept a non-URI as the source" do - lambda { @resource.source("not-a-uri") }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI) + expect { @resource.source("not-a-uri") }.to raise_error(Chef::Exceptions::InvalidRemoteFileURI) end it "does not accept a non-URI as the source when read from a delayed evaluator" do - lambda { + expect { @resource.source(Chef::DelayedEvaluator.new {"not-a-uri"}) @resource.source - }.should raise_error(Chef::Exceptions::InvalidRemoteFileURI) + }.to raise_error(Chef::Exceptions::InvalidRemoteFileURI) end it "should raise an exception when source is an empty array" do - lambda { @resource.source([]) }.should raise_error(ArgumentError) + expect { @resource.source([]) }.to raise_error(ArgumentError) end end @@ -102,51 +102,51 @@ describe Chef::Resource::RemoteFile do describe "checksum" do it "should accept a string for the checksum object" do @resource.checksum "asdf" - @resource.checksum.should eql("asdf") + expect(@resource.checksum).to eql("asdf") end it "should default to nil" do - @resource.checksum.should == nil + expect(@resource.checksum).to eq(nil) end end describe "ftp_active_mode" do it "should accept a boolean for the ftp_active_mode object" do @resource.ftp_active_mode true - @resource.ftp_active_mode.should be_true + expect(@resource.ftp_active_mode).to be_true end it "should default to false" do - @resource.ftp_active_mode.should be_false + expect(@resource.ftp_active_mode).to be_false end end describe "conditional get options" do it "defaults to using etags and last modified" do - @resource.use_etags.should be_true - @resource.use_last_modified.should be_true + expect(@resource.use_etags).to be_true + expect(@resource.use_last_modified).to be_true end it "enable or disables etag and last modified options as a group" do @resource.use_conditional_get(false) - @resource.use_etags.should be_false - @resource.use_last_modified.should be_false + expect(@resource.use_etags).to be_false + expect(@resource.use_last_modified).to be_false @resource.use_conditional_get(true) - @resource.use_etags.should be_true - @resource.use_last_modified.should be_true + expect(@resource.use_etags).to be_true + expect(@resource.use_last_modified).to be_true end it "disables etags indivdually" do @resource.use_etags(false) - @resource.use_etags.should be_false - @resource.use_last_modified.should be_true + expect(@resource.use_etags).to be_false + expect(@resource.use_last_modified).to be_true end it "disables last modified individually" do @resource.use_last_modified(false) - @resource.use_last_modified.should be_false - @resource.use_etags.should be_true + expect(@resource.use_last_modified).to be_false + expect(@resource.use_etags).to be_true end end @@ -171,21 +171,21 @@ describe Chef::Resource::RemoteFile do state = @resource.state if Chef::Platform.windows? puts state - state[:rights].should == [{:permissions => :read, :principals => "Everyone"}] - state[:deny_rights].should == [{:permissions => :full_control, :principals => "Clumsy_Sam"}] + expect(state[:rights]).to eq([{:permissions => :read, :principals => "Everyone"}]) + expect(state[:deny_rights]).to eq([{:permissions => :full_control, :principals => "Clumsy_Sam"}]) else - state[:group].should == "pokemon" - state[:mode].should == "0664" - state[:owner].should == "root" - state[:checksum].should == "1"*26 + expect(state[:group]).to eq("pokemon") + expect(state[:mode]).to eq("0664") + expect(state[:owner]).to eq("root") + expect(state[:checksum]).to eq("1"*26) end end it "returns the path as its identity" do if Chef::Platform.windows? - @resource.identity.should == "C:/temp/origin/file.txt" + expect(@resource.identity).to eq("C:/temp/origin/file.txt") else - @resource.identity.should == "/this/path/" + expect(@resource.identity).to eq("/this/path/") end end end diff --git a/spec/unit/resource/route_spec.rb b/spec/unit/resource/route_spec.rb index 4522438402..ec1d369932 100644 --- a/spec/unit/resource/route_spec.rb +++ b/spec/unit/resource/route_spec.rb @@ -26,64 +26,64 @@ describe Chef::Resource::Route do end it "should create a new Chef::Resource::Route" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Route) + 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 - @resource.name.should eql("10.0.0.10") + expect(@resource.name).to eql("10.0.0.10") end it "should have a default action of 'add'" do - @resource.action.should eql([:add]) + expect(@resource.action).to eql([:add]) end it "should accept add or delete for action" do - lambda { @resource.action :add }.should_not raise_error - lambda { @resource.action :delete }.should_not raise_error - lambda { @resource.action :lolcat }.should raise_error(ArgumentError) + 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 - @resource.target.should eql("10.0.0.10") + 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" - @resource.netmask.should eql("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" - @resource.gateway.should eql("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 - @resource.metric.should eql(10) + expect(@resource.metric).to eql(10) end it "should allow you to specify the device" do @resource.device "eth0" - @resource.device.should eql("eth0") + expect(@resource.device).to eql("eth0") end it "should allow you to specify the route type" do @resource.route_type "host" - @resource.route_type.should eql(:host) + expect(@resource.route_type).to eql(:host) end it "should default to a host route type" do - @resource.route_type.should eql(:host) + expect(@resource.route_type).to eql(:host) end it "should accept a net route type" do @resource.route_type :net - @resource.route_type.should eql(:net) + expect(@resource.route_type).to eql(:net) end it "should reject any other route_type but :host and :net" do - lambda { @resource.route_type "lolcat" }.should raise_error(ArgumentError) + expect { @resource.route_type "lolcat" }.to raise_error(ArgumentError) end describe "when it has netmask, gateway, and device" do @@ -96,12 +96,12 @@ describe Chef::Resource::Route do it "describes its state" do state = @resource.state - state[:netmask].should == "lemask" - state[:gateway].should == "111.111.111" + expect(state[:netmask]).to eq("lemask") + expect(state[:gateway]).to eq("111.111.111") end it "returns the target as its identity" do - @resource.identity.should == "charmander" + expect(@resource.identity).to eq("charmander") end end end diff --git a/spec/unit/resource/ruby_block_spec.rb b/spec/unit/resource/ruby_block_spec.rb index 82bbd1ffc7..9f19fecd4f 100644 --- a/spec/unit/resource/ruby_block_spec.rb +++ b/spec/unit/resource/ruby_block_spec.rb @@ -26,27 +26,27 @@ describe Chef::Resource::RubyBlock do end it "should create a new Chef::Resource::RubyBlock" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::RubyBlock) + 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 'create'" do - @resource.action.should eql("run") + expect(@resource.action).to eql("run") end it "should have a resource name of :ruby_block" do - @resource.resource_name.should eql(:ruby_block) + expect(@resource.resource_name).to eql(:ruby_block) end it "should accept a ruby block/proc/.. for the 'block' parameter" do - @resource.block do + expect(@resource.block do "foo" - end.call.should eql("foo") + end.call).to eql("foo") end it "allows the action to be 'create'" do @resource.action :create - @resource.action.should == [:create] + expect(@resource.action).to eq([:create]) end describe "when it has been initialized with block code" do @@ -55,7 +55,7 @@ describe Chef::Resource::RubyBlock do end it "returns the block as its identity" do - @resource.identity.should == "puts 'harrrr'" + expect(@resource.identity).to eq("puts 'harrrr'") end end end diff --git a/spec/unit/resource/ruby_spec.rb b/spec/unit/resource/ruby_spec.rb index 9bf7316e6d..e899810ab9 100644 --- a/spec/unit/resource/ruby_spec.rb +++ b/spec/unit/resource/ruby_spec.rb @@ -25,16 +25,16 @@ describe Chef::Resource::Ruby do end it "should create a new Chef::Resource::Ruby" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Ruby) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::Ruby) end it "should have a resource name of :ruby" do - @resource.resource_name.should eql(:ruby) + expect(@resource.resource_name).to eql(:ruby) end it "should have an interpreter of ruby" do - @resource.interpreter.should eql("ruby") + expect(@resource.interpreter).to eql("ruby") end end diff --git a/spec/unit/resource/scm_spec.rb b/spec/unit/resource/scm_spec.rb index eeb2fb1c3c..daabdd03ba 100644 --- a/spec/unit/resource/scm_spec.rb +++ b/spec/unit/resource/scm_spec.rb @@ -26,141 +26,141 @@ describe Chef::Resource::Scm do end it "should be a SCM resource" do - @resource.should be_a_kind_of(Chef::Resource::Scm) + expect(@resource).to be_a_kind_of(Chef::Resource::Scm) end it "supports :checkout, :export, :sync, :diff, and :log actions" do - @resource.allowed_actions.should include(:checkout) - @resource.allowed_actions.should include(:export) - @resource.allowed_actions.should include(:sync) - @resource.allowed_actions.should include(:diff) - @resource.allowed_actions.should 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" - @resource.destination.should eql("/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" - @resource.repository.should eql("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" - @resource.revision.should eql("abcdef") + expect(@resource.revision).to eql("abcdef") end it "defaults to the ``HEAD'' revision" do - @resource.revision.should eql("HEAD") + expect(@resource.revision).to eql("HEAD") end it "takes a string for the user to run as" do @resource.user "dr_deploy" - @resource.user.should eql("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 - @resource.user.should eql(0) + expect(@resource.user).to eql(0) end it "takes a string for the group to run as, defaulting to nil" do - @resource.group.should be_nil + expect(@resource.group).to be_nil @resource.group "opsdevs" - @resource.group.should == "opsdevs" + expect(@resource.group).to eq("opsdevs") end it "also takes an integer for the group to run as" do @resource.group 23 - @resource.group.should == 23 + expect(@resource.group).to eq(23) end it "has a svn_username String attribute" do @resource.svn_username "moartestsplz" - @resource.svn_username.should eql("moartestsplz") + expect(@resource.svn_username).to eql("moartestsplz") end it "has a svn_password String attribute" do @resource.svn_password "taftplz" - @resource.svn_password.should eql("taftplz") + expect(@resource.svn_password).to eql("taftplz") end it "has a svn_arguments String attribute" do @resource.svn_arguments "--more-taft plz" - @resource.svn_arguments.should eql("--more-taft plz") + expect(@resource.svn_arguments).to eql("--more-taft plz") end it "has a svn_info_args String attribute" do - @resource.svn_info_args.should be_nil + expect(@resource.svn_info_args).to be_nil @resource.svn_info_args("--no-moar-plaintext-creds yep") - @resource.svn_info_args.should == "--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 - @resource.depth.should == 5 - lambda {@resource.depth "five"}.should raise_error(ArgumentError) + 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 - @resource.depth.should be_nil + expect(@resource.depth).to be_nil end it "takes a boolean for #enable_submodules" do @resource.enable_submodules true - @resource.enable_submodules.should be_true - lambda {@resource.enable_submodules "lolz"}.should raise_error(ArgumentError) + expect(@resource.enable_submodules).to be_true + expect {@resource.enable_submodules "lolz"}.to raise_error(ArgumentError) end it "defaults to not enabling submodules" do - @resource.enable_submodules.should be_false + expect(@resource.enable_submodules).to be_false end it "takes a boolean for #enable_checkout" do @resource.enable_checkout true - @resource.enable_checkout.should be_true - lambda {@resource.enable_checkout "lolz"}.should raise_error(ArgumentError) + expect(@resource.enable_checkout).to be_true + expect {@resource.enable_checkout "lolz"}.to raise_error(ArgumentError) end it "defaults to enabling checkout" do - @resource.enable_checkout.should be_true + expect(@resource.enable_checkout).to be_true end it "takes a string for the remote" do @resource.remote "opscode" - @resource.remote.should eql("opscode") - lambda {@resource.remote 1337}.should raise_error(ArgumentError) + expect(@resource.remote).to eql("opscode") + expect {@resource.remote 1337}.to raise_error(ArgumentError) end it "defaults to ``origin'' for the remote" do - @resource.remote.should == "origin" + expect(@resource.remote).to eq("origin") end it "takes a string for the ssh wrapper" do @resource.ssh_wrapper "with_ssh_fu" - @resource.ssh_wrapper.should eql("with_ssh_fu") + expect(@resource.ssh_wrapper).to eql("with_ssh_fu") end it "defaults to nil for the ssh wrapper" do - @resource.ssh_wrapper.should be_nil + expect(@resource.ssh_wrapper).to be_nil end it "defaults to nil for the environment" do - @resource.environment.should 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) } it "stores this timeout" do - @resource.timeout.should == 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 - @resource.timeout.should be_nil + expect(@resource.timeout).to be_nil end end @@ -175,11 +175,11 @@ describe Chef::Resource::Scm do it "describes its state" do state = @resource.state - state[:revision].should == "1.2.3" + expect(state[:revision]).to eq("1.2.3") end it "returns the destination as its identity" do - @resource.identity.should == "hell" + expect(@resource.identity).to eq("hell") end end @@ -187,7 +187,7 @@ describe Chef::Resource::Scm do let(:test_environment) { {'CHEF_ENV' => '/tmp' } } before { @resource.environment(test_environment) } it "stores this environment" do - @resource.environment.should == test_environment + expect(@resource.environment).to eq(test_environment) end end end diff --git a/spec/unit/resource/script_spec.rb b/spec/unit/resource/script_spec.rb index f100b0dc85..9d744baaa5 100644 --- a/spec/unit/resource/script_spec.rb +++ b/spec/unit/resource/script_spec.rb @@ -26,7 +26,7 @@ describe Chef::Resource::Script do it "should accept a string for the interpreter" do script_resource.interpreter "naaaaNaNaNaaNaaNaaNaa" - script_resource.interpreter.should eql("naaaaNaNaNaaNaaNaaNaa") + expect(script_resource.interpreter).to eql("naaaaNaNaNaaNaaNaaNaa") end describe "when it has interpreter and flags" do @@ -37,7 +37,7 @@ describe Chef::Resource::Script do end it "returns the command as its identity" do - script_resource.identity.should == "grep" + expect(script_resource.identity).to eq("grep") end end diff --git a/spec/unit/resource/service_spec.rb b/spec/unit/resource/service_spec.rb index 9b779e5830..eb6f444e93 100644 --- a/spec/unit/resource/service_spec.rb +++ b/spec/unit/resource/service_spec.rb @@ -26,135 +26,135 @@ describe Chef::Resource::Service do end it "should create a new Chef::Resource::Service" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::Service) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::Service) end it "should not set a provider unless node[:init_package] is defined as systemd" do - @resource.provider.should == nil + expect(@resource.provider).to eq(nil) end it "should set the service_name to the first argument to new" do - @resource.service_name.should eql("chef") + expect(@resource.service_name).to eql("chef") end it "should set the pattern to be the service name by default" do - @resource.pattern.should eql("chef") + expect(@resource.pattern).to eql("chef") end it "should accept a string for the service name" do @resource.service_name "something" - @resource.service_name.should eql("something") + expect(@resource.service_name).to eql("something") end it "should accept a string for the service pattern" do @resource.pattern ".*" - @resource.pattern.should eql(".*") + expect(@resource.pattern).to eql(".*") end it "should not accept a regexp for the service pattern" do - lambda { + expect { @resource.pattern /.*/ - }.should raise_error(ArgumentError) + }.to raise_error(ArgumentError) end it "should accept a string for the service start command" do @resource.start_command "/etc/init.d/chef start" - @resource.start_command.should eql("/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 - lambda { + expect { @resource.start_command /.*/ - }.should raise_error(ArgumentError) + }.to raise_error(ArgumentError) end it "should accept a string for the service stop command" do @resource.stop_command "/etc/init.d/chef stop" - @resource.stop_command.should eql("/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 - lambda { + expect { @resource.stop_command /.*/ - }.should raise_error(ArgumentError) + }.to raise_error(ArgumentError) end it "should accept a string for the service status command" do @resource.status_command "/etc/init.d/chef status" - @resource.status_command.should eql("/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 - lambda { + expect { @resource.status_command /.*/ - }.should raise_error(ArgumentError) + }.to raise_error(ArgumentError) end it "should accept a string for the service restart command" do @resource.restart_command "/etc/init.d/chef restart" - @resource.restart_command.should eql("/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 - lambda { + expect { @resource.restart_command /.*/ - }.should raise_error(ArgumentError) + }.to raise_error(ArgumentError) end it "should accept a string for the service reload command" do @resource.reload_command "/etc/init.d/chef reload" - @resource.reload_command.should eql("/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 - lambda { + expect { @resource.reload_command /.*/ - }.should raise_error(ArgumentError) + }.to raise_error(ArgumentError) end it "should accept a string for the service init command" do @resource.init_command "/etc/init.d/chef" - @resource.init_command.should eql("/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 - lambda { + expect { @resource.init_command /.*/ - }.should raise_error(ArgumentError) + }.to raise_error(ArgumentError) end %w{enabled running}.each do |attrib| it "should accept true for #{attrib}" do @resource.send(attrib, true) - @resource.send(attrib).should eql(true) + expect(@resource.send(attrib)).to eql(true) end it "should accept false for #{attrib}" do @resource.send(attrib, false) - @resource.send(attrib).should eql(false) + expect(@resource.send(attrib)).to eql(false) end it "should not accept a string for #{attrib}" do - lambda { @resource.send(attrib, "poop") }.should raise_error(ArgumentError) + expect { @resource.send(attrib, "poop") }.to raise_error(ArgumentError) end it "should default all the feature support to false" do support_hash = { :status => false, :restart => false, :reload=> false } - @resource.supports.should == 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 support_array = [ :status, :restart ] support_hash = { :status => true, :restart => true, :reload => false } @resource.supports(support_array) - @resource.supports.should == support_hash + expect(@resource.supports).to eq(support_hash) end it "should allow you to set what features this resource supports as a hash" do support_hash = { :status => true, :restart => true, :reload => false } @resource.supports(support_hash) - @resource.supports.should == support_hash + expect(@resource.supports).to eq(support_hash) end end @@ -167,12 +167,12 @@ describe Chef::Resource::Service do it "describes its state" do state = @resource.state - state[:enabled].should eql(true) - state[:running].should eql(false) + expect(state[:enabled]).to eql(true) + expect(state[:running]).to eql(false) end it "returns the service name as its identity" do - @resource.identity.should == "superfriend" + expect(@resource.identity).to eq("superfriend") end end diff --git a/spec/unit/resource/solaris_package_spec.rb b/spec/unit/resource/solaris_package_spec.rb index ab4e03807d..f5d3e669a1 100644 --- a/spec/unit/resource/solaris_package_spec.rb +++ b/spec/unit/resource/solaris_package_spec.rb @@ -37,6 +37,6 @@ describe Chef::Resource::SolarisPackage, "initialize" do end it "should set the package_name to the name provided" do - @resource.package_name.should eql("foo") + expect(@resource.package_name).to eql("foo") end end diff --git a/spec/unit/resource/subversion_spec.rb b/spec/unit/resource/subversion_spec.rb index a52d8421c6..4cbca9be11 100644 --- a/spec/unit/resource/subversion_spec.rb +++ b/spec/unit/resource/subversion_spec.rb @@ -33,35 +33,35 @@ describe Chef::Resource::Subversion do end it "is a subclass of Resource::Scm" do - @svn.should be_an_instance_of(Chef::Resource::Subversion) - @svn.should be_a_kind_of(Chef::Resource::Scm) + expect(@svn).to be_an_instance_of(Chef::Resource::Subversion) + expect(@svn).to be_a_kind_of(Chef::Resource::Scm) end it "allows the force_export action" do - @svn.allowed_actions.should include(:force_export) + expect(@svn.allowed_actions).to include(:force_export) end it "sets svn info arguments to --no-auth-cache by default" do - @svn.svn_info_args.should == '--no-auth-cache' + expect(@svn.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) - @svn.svn_info_args.should be_nil + expect(@svn.svn_info_args).to be_nil end it "sets svn arguments to --no-auth-cache by default" do - @svn.svn_arguments.should == '--no-auth-cache' + expect(@svn.svn_arguments).to eq('--no-auth-cache') end it "resets svn arguments to nil when given false in the setter" do @svn.svn_arguments(false) - @svn.svn_arguments.should be_nil + expect(@svn.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}") - e.message.include?(@svn.svn_password).should be_false + expect(e.message.include?(@svn.svn_password)).to be_false end end diff --git a/spec/unit/resource/template_spec.rb b/spec/unit/resource/template_spec.rb index c9dfdc7014..df5ca94b8a 100644 --- a/spec/unit/resource/template_spec.rb +++ b/spec/unit/resource/template_spec.rb @@ -26,54 +26,54 @@ describe Chef::Resource::Template do describe "initialize" do it "should create a new Chef::Resource::Template" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::File) - @resource.should be_a_kind_of(Chef::Resource::Template) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::File) + expect(@resource).to be_a_kind_of(Chef::Resource::Template) end end describe "source" do it "should accept a string for the template source" do @resource.source "something" - @resource.source.should eql("something") + expect(@resource.source).to eql("something") end it "should have a default based on the param name with .erb appended" do - @resource.source.should eql("fakey_fakerton.erb") + expect(@resource.source).to eql("fakey_fakerton.erb") end it "should use only the basename of the file as the default" do r = Chef::Resource::Template.new("/tmp/obit/fakey_fakerton") - r.source.should eql("fakey_fakerton.erb") + expect(r.source).to eql("fakey_fakerton.erb") end end describe "variables" do it "should accept a hash for the variable list" do @resource.variables({ :reluctance => :awkward }) - @resource.variables.should == { :reluctance => :awkward } + expect(@resource.variables).to eq({ :reluctance => :awkward }) end end describe "cookbook" do it "should accept a string for the cookbook name" do @resource.cookbook("foo") - @resource.cookbook.should == "foo" + expect(@resource.cookbook).to eq("foo") end it "should default to nil" do - @resource.cookbook.should == nil + expect(@resource.cookbook).to eq(nil) end end describe "local" do it "should accept a boolean for whether a template is local or remote" do @resource.local(true) - @resource.local.should == true + expect(@resource.local).to eq(true) end it "should default to false" do - @resource.local.should == false + expect(@resource.local).to eq(false) end end @@ -89,10 +89,10 @@ describe Chef::Resource::Template do context "on unix", :unix_only do it "describes its state" do state = @resource.state - state[:owner].should == "root" - state[:group].should == "wheel" - state[:mode].should == "0644" - state[:checksum].should == "1" * 64 + expect(state[:owner]).to eq("root") + expect(state[:group]).to eq("wheel") + expect(state[:mode]).to eq("0644") + expect(state[:checksum]).to eq("1" * 64) end end @@ -102,7 +102,7 @@ describe Chef::Resource::Template do end it "returns the file path as its identity" do - @resource.identity.should == "/tmp/foo.txt" + expect(@resource.identity).to eq("/tmp/foo.txt") end end @@ -117,19 +117,19 @@ describe Chef::Resource::Template do it "collects helper method bodies as blocks" do @resource.helper(:example_1) { "example_1" } @resource.helper(:example_2) { "example_2" } - @resource.inline_helper_blocks[:example_1].call.should == "example_1" - @resource.inline_helper_blocks[:example_2].call.should == "example_2" + expect(@resource.inline_helper_blocks[:example_1].call).to eq("example_1") + expect(@resource.inline_helper_blocks[:example_2].call).to eq("example_2") end it "compiles helper methods into a module" do @resource.helper(:example_1) { "example_1" } @resource.helper(:example_2) { "example_2" } modules = @resource.helper_modules - modules.should have(1).module + expect(modules.size).to eq(1) o = Object.new modules.each {|m| o.extend(m)} - o.example_1.should == "example_1" - o.example_2.should == "example_2" + expect(o.example_1).to eq("example_1") + expect(o.example_2).to eq("example_2") end it "compiles helper methods with arguments into a module" do @@ -137,15 +137,15 @@ describe Chef::Resource::Template do modules = @resource.helper_modules o = Object.new modules.each {|m| o.extend(m)} - o.shout("shout").should == "SHOUT" + expect(o.shout("shout")).to eq("SHOUT") end it "raises an error when attempting to define a helper method without a method body" do - lambda { @resource.helper(:example) }.should raise_error(Chef::Exceptions::ValidationFailed) + expect { @resource.helper(:example) }.to raise_error(Chef::Exceptions::ValidationFailed) end it "raises an error when attempting to define a helper method with a non-Symbod method name" do - lambda { @resource.helper("example") { "fail" } }.should raise_error(Chef::Exceptions::ValidationFailed) + expect { @resource.helper("example") { "fail" } }.to raise_error(Chef::Exceptions::ValidationFailed) end it "collects helper module bodies as blocks" do @@ -155,7 +155,7 @@ describe Chef::Resource::Template do end end module_body = @resource.inline_helper_modules.first - module_body.should be_a(Proc) + expect(module_body).to be_a(Proc) end it "compiles helper module bodies into modules" do @@ -165,27 +165,27 @@ describe Chef::Resource::Template do end end modules = @resource.helper_modules - modules.should have(1).module + expect(modules.size).to eq(1) o = Object.new modules.each {|m| o.extend(m)} - o.example_1.should == "example_1" + expect(o.example_1).to eq("example_1") end it "raises an error when no block or module name is given for helpers definition" do - lambda { @resource.helpers() }.should raise_error(Chef::Exceptions::ValidationFailed) + expect { @resource.helpers() }.to raise_error(Chef::Exceptions::ValidationFailed) end it "raises an error when a non-module is given for helpers definition" do - lambda { @resource.helpers("NotAModule") }.should raise_error(Chef::Exceptions::ValidationFailed) + expect { @resource.helpers("NotAModule") }.to raise_error(Chef::Exceptions::ValidationFailed) end it "raises an error when a module name and block are both given for helpers definition" do - lambda { @resource.helpers(ExampleHelpers) { module_code } }.should raise_error(Chef::Exceptions::ValidationFailed) + expect { @resource.helpers(ExampleHelpers) { module_code } }.to raise_error(Chef::Exceptions::ValidationFailed) end it "collects helper modules" do @resource.helpers(ExampleHelpers) - @resource.helper_modules.should include(ExampleHelpers) + expect(@resource.helper_modules).to include(ExampleHelpers) end it "combines all helpers into a set of compiled modules" do @@ -196,13 +196,13 @@ describe Chef::Resource::Template do end end @resource.helper(:inline_method) { "inline_method" } - @resource.should have(3).helper_modules + expect(@resource.helper_modules.size).to eq(3) o = Object.new @resource.helper_modules.each {|m| o.extend(m)} - o.static_example.should == "static_example" - o.inline_module.should == "inline_module" - o.inline_method.should == "inline_method" + expect(o.static_example).to eq("static_example") + expect(o.inline_module).to eq("inline_module") + expect(o.inline_method).to eq("inline_method") end diff --git a/spec/unit/resource/user_spec.rb b/spec/unit/resource/user_spec.rb index 70b866202b..f05de94fe0 100644 --- a/spec/unit/resource/user_spec.rb +++ b/spec/unit/resource/user_spec.rb @@ -24,51 +24,51 @@ describe Chef::Resource::User, "initialize" do end it "should create a new Chef::Resource::User" do - @resource.should be_a_kind_of(Chef::Resource) - @resource.should be_a_kind_of(Chef::Resource::User) + expect(@resource).to be_a_kind_of(Chef::Resource) + expect(@resource).to be_a_kind_of(Chef::Resource::User) end it "should set the resource_name to :user" do - @resource.resource_name.should eql(:user) + expect(@resource.resource_name).to eql(:user) end it "should set the username equal to the argument to initialize" do - @resource.username.should eql("adam") + expect(@resource.username).to eql("adam") end %w{comment uid gid home shell password}.each do |attrib| it "should set #{attrib} to nil" do - @resource.send(attrib).should eql(nil) + expect(@resource.send(attrib)).to eql(nil) end end it "should set action to :create" do - @resource.action.should eql(:create) + expect(@resource.action).to eql(:create) end it "should set supports[:manage_home] to false" do - @resource.supports[:manage_home].should eql(false) + expect(@resource.supports[:manage_home]).to eql(false) end it "should set supports[:non_unique] to false" do - @resource.supports[:non_unique].should eql(false) + expect(@resource.supports[:non_unique]).to eql(false) end it "should set force to false" do - @resource.force.should eql(false) + expect(@resource.force).to eql(false) end %w{create remove modify manage lock unlock}.each do |action| it "should allow action #{action}" do - @resource.allowed_actions.detect { |a| a == action.to_sym }.should eql(action.to_sym) + expect(@resource.allowed_actions.detect { |a| a == action.to_sym }).to eql(action.to_sym) end end it "should accept domain users (@ or \ separator) on non-windows" do - lambda { @resource.username "domain\@user" }.should_not raise_error - @resource.username.should == "domain\@user" - lambda { @resource.username "domain\\user" }.should_not raise_error - @resource.username.should == "domain\\user" + expect { @resource.username "domain\@user" }.not_to raise_error + expect(@resource.username).to eq("domain\@user") + expect { @resource.username "domain\\user" }.not_to raise_error + expect(@resource.username).to eq("domain\\user") end end @@ -80,11 +80,11 @@ end it "should allow a string" do @resource.send(attrib, "adam") - @resource.send(attrib).should eql("adam") + expect(@resource.send(attrib)).to eql("adam") end it "should not allow a hash" do - lambda { @resource.send(attrib, { :woot => "i found it" }) }.should raise_error(ArgumentError) + expect { @resource.send(attrib, { :woot => "i found it" }) }.to raise_error(ArgumentError) end end end @@ -97,16 +97,16 @@ end it "should allow a string" do @resource.send(attrib, "100") - @resource.send(attrib).should eql("100") + expect(@resource.send(attrib)).to eql("100") end it "should allow an integer" do @resource.send(attrib, 100) - @resource.send(attrib).should eql(100) + expect(@resource.send(attrib)).to eql(100) end it "should not allow a hash" do - lambda { @resource.send(attrib, { :woot => "i found it" }) }.should raise_error(ArgumentError) + expect { @resource.send(attrib, { :woot => "i found it" }) }.to raise_error(ArgumentError) end end @@ -120,13 +120,13 @@ end it "describes its state" do state = @resource.state - state[:uid].should == 123 - state[:gid].should == 456 - state[:home].should == "/usr/local/root/" + expect(state[:uid]).to eq(123) + expect(state[:gid]).to eq(456) + expect(state[:home]).to eq("/usr/local/root/") end it "returns the username as its identity" do - @resource.identity.should == "root" + expect(@resource.identity).to eq("root") end end diff --git a/spec/unit/resource/windows_package_spec.rb b/spec/unit/resource/windows_package_spec.rb index c9ef8d910c..3c45548ece 100644 --- a/spec/unit/resource/windows_package_spec.rb +++ b/spec/unit/resource/windows_package_spec.rb @@ -56,13 +56,13 @@ describe Chef::Resource::WindowsPackage, "initialize", :windows_only do end it "coverts a source to an absolute path" do - ::File.stub(:absolute_path).and_return("c:\\Files\\frost.msi") + allow(::File).to receive(:absolute_path).and_return("c:\\Files\\frost.msi") resource.source("frost.msi") expect(resource.source).to eql "c:\\Files\\frost.msi" end it "converts slashes to backslashes in the source path" do - ::File.stub(:absolute_path).and_return("c:\\frost.msi") + allow(::File).to receive(:absolute_path).and_return("c:\\frost.msi") resource.source("c:/frost.msi") expect(resource.source).to eql "c:\\frost.msi" end diff --git a/spec/unit/resource/windows_service_spec.rb b/spec/unit/resource/windows_service_spec.rb index c92c3be1b0..fd7bedec9f 100644 --- a/spec/unit/resource/windows_service_spec.rb +++ b/spec/unit/resource/windows_service_spec.rb @@ -41,6 +41,6 @@ describe Chef::Resource::WindowsService, "initialize", :windows_only do it "allows the action to be 'configure_startup'" do resource.action :configure_startup - resource.action.should == [:configure_startup] + expect(resource.action).to eq([:configure_startup]) end end diff --git a/spec/unit/resource/yum_package_spec.rb b/spec/unit/resource/yum_package_spec.rb index 7e1979fdfd..e01b87c580 100644 --- a/spec/unit/resource/yum_package_spec.rb +++ b/spec/unit/resource/yum_package_spec.rb @@ -39,7 +39,7 @@ describe Chef::Resource::YumPackage, "arch" do it "should set the arch variable to whatever is passed in" do @resource.arch("i386") - @resource.arch.should eql("i386") + expect(@resource.arch).to eql("i386") end end @@ -50,20 +50,20 @@ describe Chef::Resource::YumPackage, "flush_cache" do it "should default the flush timing to false" do flush_hash = { :before => false, :after => false } - @resource.flush_cache.should == flush_hash + expect(@resource.flush_cache).to eq(flush_hash) end it "should allow you to set the flush timing with an array" do flush_array = [ :before, :after ] flush_hash = { :before => true, :after => true } @resource.flush_cache(flush_array) - @resource.flush_cache.should == flush_hash + expect(@resource.flush_cache).to eq(flush_hash) end it "should allow you to set the flush timing with a hash" do flush_hash = { :before => true, :after => true } @resource.flush_cache(flush_hash) - @resource.flush_cache.should == flush_hash + expect(@resource.flush_cache).to eq(flush_hash) end end @@ -73,8 +73,8 @@ describe Chef::Resource::YumPackage, "allow_downgrade" do end it "should allow you to specify whether allow_downgrade is true or false" do - lambda { @resource.allow_downgrade true }.should_not raise_error - lambda { @resource.allow_downgrade false }.should_not raise_error - lambda { @resource.allow_downgrade "monkey" }.should raise_error(ArgumentError) + 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 |