diff options
Diffstat (limited to 'spec/unit/knife')
66 files changed, 1401 insertions, 1401 deletions
diff --git a/spec/unit/knife/bootstrap_spec.rb b/spec/unit/knife/bootstrap_spec.rb index 2599e44a56..4de2b4531d 100644 --- a/spec/unit/knife/bootstrap_spec.rb +++ b/spec/unit/knife/bootstrap_spec.rb @@ -23,7 +23,7 @@ require 'net/ssh' describe Chef::Knife::Bootstrap do before do - Chef::Platform.stub(:windows?) { false } + allow(Chef::Platform).to receive(:windows?) { false } end let(:knife) do Chef::Log.logger = Logger.new(StringIO.new) @@ -32,7 +32,7 @@ describe Chef::Knife::Bootstrap do k = Chef::Knife::Bootstrap.new k.merge_configs - k.ui.stub(:stderr).and_return(stderr) + allow(k.ui).to receive(:stderr).and_return(stderr) allow(k).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(false) k end @@ -42,8 +42,8 @@ describe Chef::Knife::Bootstrap do let(:bootstrap_template) { nil } it "should use chef-full as default template" do - knife.bootstrap_template.should be_a_kind_of(String) - File.basename(knife.bootstrap_template).should eq("chef-full") + expect(knife.bootstrap_template).to be_a_kind_of(String) + expect(File.basename(knife.bootstrap_template)).to eq("chef-full") end context "when finding templates" do @@ -52,7 +52,7 @@ describe Chef::Knife::Bootstrap do let(:bootstrap_template) { "/opt/blah/not/exists/template.erb" } it "raises an error" do - lambda { knife.find_template }.should raise_error + expect { knife.find_template }.to raise_error end end @@ -60,8 +60,8 @@ describe Chef::Knife::Bootstrap do let(:bootstrap_template) { File.expand_path(File.join(CHEF_SPEC_DATA, "bootstrap", "test.erb")) } it "loads the given file as the template" do - Chef::Log.should_receive(:debug) - knife.find_template.should eq(File.expand_path(File.join(CHEF_SPEC_DATA, "bootstrap", "test.erb"))) + expect(Chef::Log).to receive(:debug) + expect(knife.find_template).to eq(File.expand_path(File.join(CHEF_SPEC_DATA, "bootstrap", "test.erb"))) end end end @@ -78,7 +78,7 @@ describe Chef::Knife::Bootstrap do let(:gem_files_template_path) { "/Users/schisamo/.rvm/gems/ruby-1.9.2-p180@chef-0.10/gems/knife-windows-0.5.4/lib/chef/knife/bootstrap/fake-bootstrap-template.erb" } def configure_chef_config_dir - Chef::Knife.stub(:chef_config_dir).and_return("/knife/chef/config") + allow(Chef::Knife).to receive(:chef_config_dir).and_return("/knife/chef/config") end def configure_env_home @@ -86,13 +86,13 @@ describe Chef::Knife::Bootstrap do end def configure_gem_files - Gem.stub(:find_files).and_return([ gem_files_template_path ]) + allow(Gem).to receive(:find_files).and_return([ gem_files_template_path ]) end before(:each) do @original_home = ENV['HOME'] ENV['HOME'] = nil - File.should_receive(:exists?).with(bootstrap_template).and_return(false) + expect(File).to receive(:exists?).with(bootstrap_template).and_return(false) end after(:each) do @@ -105,11 +105,11 @@ describe Chef::Knife::Bootstrap do configure_env_home configure_gem_files - File.should_receive(:exists?).with(builtin_template_path).and_return(true) + expect(File).to receive(:exists?).with(builtin_template_path).and_return(true) end it "should load the template from built-in templates" do - knife.find_template.should eq(builtin_template_path) + expect(knife.find_template).to eq(builtin_template_path) end end @@ -119,8 +119,8 @@ describe Chef::Knife::Bootstrap do configure_env_home configure_gem_files - File.should_receive(:exists?).with(builtin_template_path).and_return(false) - File.should_receive(:exists?).with(chef_config_dir_template_path).and_return(true) + expect(File).to receive(:exists?).with(builtin_template_path).and_return(false) + expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(true) it "should load the template from chef_config_dir" do knife.find_template.should eq(chef_config_dir_template_path) @@ -134,13 +134,13 @@ describe Chef::Knife::Bootstrap do configure_env_home configure_gem_files - File.should_receive(:exists?).with(builtin_template_path).and_return(false) - File.should_receive(:exists?).with(chef_config_dir_template_path).and_return(false) - File.should_receive(:exists?).with(env_home_template_path).and_return(true) + expect(File).to receive(:exists?).with(builtin_template_path).and_return(false) + expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false) + expect(File).to receive(:exists?).with(env_home_template_path).and_return(true) end it "should load the template from chef_config_dir" do - knife.find_template.should eq(env_home_template_path) + expect(knife.find_template).to eq(env_home_template_path) end end @@ -149,13 +149,13 @@ describe Chef::Knife::Bootstrap do configure_chef_config_dir configure_gem_files - File.should_receive(:exists?).with(builtin_template_path).and_return(false) - File.should_receive(:exists?).with(chef_config_dir_template_path).and_return(false) - File.should_receive(:exists?).with(gem_files_template_path).and_return(true) + expect(File).to receive(:exists?).with(builtin_template_path).and_return(false) + expect(File).to receive(:exists?).with(chef_config_dir_template_path).and_return(false) + expect(File).to receive(:exists?).with(gem_files_template_path).and_return(true) end it "should load the template from Gem files" do - knife.find_template.should eq(gem_files_template_path) + expect(knife.find_template).to eq(gem_files_template_path) end end end @@ -166,7 +166,7 @@ describe Chef::Knife::Bootstrap do it "sets the knife :bootstrap_template config" do knife.parse_options([t,"blahblah"]) knife.merge_configs - knife.bootstrap_template.should eq("blahblah") + expect(knife.bootstrap_template).to eq("blahblah") end end end @@ -175,19 +175,19 @@ describe Chef::Knife::Bootstrap do let(:bootstrap_template) { File.expand_path(File.join(CHEF_SPEC_DATA, "bootstrap", "test.erb")) } it "should return an empty run_list" do - knife.render_template.should == '{"run_list":[]}' + expect(knife.render_template).to eq('{"run_list":[]}') end it "should have role[base] in the run_list" do knife.parse_options(["-r","role[base]"]) knife.merge_configs - knife.render_template.should == '{"run_list":["role[base]"]}' + expect(knife.render_template).to eq('{"run_list":["role[base]"]}') end it "should have role[base] and recipe[cupcakes] in the run_list" do knife.parse_options(["-r", "role[base],recipe[cupcakes]"]) knife.merge_configs - knife.render_template.should == '{"run_list":["role[base]","recipe[cupcakes]"]}' + expect(knife.render_template).to eq('{"run_list":["role[base]","recipe[cupcakes]"]}') end it "should have foo => {bar => baz} in the first_boot" do @@ -195,7 +195,7 @@ describe Chef::Knife::Bootstrap do knife.merge_configs expected_hash = FFI_Yajl::Parser.new.parse('{"foo":{"bar":"baz"},"run_list":[]}') actual_hash = FFI_Yajl::Parser.new.parse(knife.render_template) - actual_hash.should == expected_hash + expect(actual_hash).to eq(expected_hash) end end @@ -205,14 +205,14 @@ describe Chef::Knife::Bootstrap do it "should create a hint file when told to" do knife.parse_options(["--hint", "openstack"]) knife.merge_configs - knife.render_template.should match /\/etc\/chef\/ohai\/hints\/openstack.json/ + expect(knife.render_template).to match /\/etc\/chef\/ohai\/hints\/openstack.json/ end it "should populate a hint file with JSON when given a file to read" do - ::File.stub(:read).and_return('{ "foo" : "bar" }') + allow(::File).to receive(:read).and_return('{ "foo" : "bar" }') knife.parse_options(["--hint", "openstack=hints/openstack.json"]) knife.merge_configs - knife.render_template.should match /\{\"foo\":\"bar\"\}/ + expect(knife.render_template).to match /\{\"foo\":\"bar\"\}/ end end @@ -235,7 +235,7 @@ describe Chef::Knife::Bootstrap do let(:setting) { "api.opscode.com" } it "renders the client.rb with a single FQDN no_proxy entry" do - rendered_template.should match(%r{.*no_proxy\s*"api.opscode.com".*}) + expect(rendered_template).to match(%r{.*no_proxy\s*"api.opscode.com".*}) end end @@ -243,7 +243,7 @@ describe Chef::Knife::Bootstrap do let(:setting) { "api.opscode.com,172.16.10.*" } it "renders the client.rb with comma-separated FQDN and wildcard IP address no_proxy entries" do - rendered_template.should match(%r{.*no_proxy\s*"api.opscode.com,172.16.10.\*".*}) + expect(rendered_template).to match(%r{.*no_proxy\s*"api.opscode.com,172.16.10.\*".*}) end end @@ -251,7 +251,7 @@ describe Chef::Knife::Bootstrap do let(:options) { ["--node-ssl-verify-mode", "none"] } it "renders the client.rb with ssl_verify_mode set to :verify_none" do - rendered_template.should match(/ssl_verify_mode :verify_none/) + expect(rendered_template).to match(/ssl_verify_mode :verify_none/) end end @@ -259,7 +259,7 @@ describe Chef::Knife::Bootstrap do let(:options) { ["--node-ssl-verify-mode", "peer"] } it "renders the client.rb with ssl_verify_mode set to :verify_peer" do - rendered_template.should match(/ssl_verify_mode :verify_peer/) + expect(rendered_template).to match(/ssl_verify_mode :verify_peer/) end end @@ -267,7 +267,7 @@ describe Chef::Knife::Bootstrap do let(:options) { ["--node-ssl-verify-mode", "all"] } it "raises error" do - lambda{ rendered_template }.should raise_error + expect{ rendered_template }.to raise_error end end @@ -275,7 +275,7 @@ describe Chef::Knife::Bootstrap do let(:options) { ["--node-verify-api-cert"] } it "renders the client.rb with verify_api_cert set to true" do - rendered_template.should match(/verify_api_cert true/) + expect(rendered_template).to match(/verify_api_cert true/) end end @@ -283,7 +283,7 @@ describe Chef::Knife::Bootstrap do let(:options) { ["--no-node-verify-api-cert"] } it "renders the client.rb with verify_api_cert set to false" do - rendered_template.should match(/verify_api_cert false/) + expect(rendered_template).to match(/verify_api_cert false/) end end end @@ -301,13 +301,13 @@ describe Chef::Knife::Bootstrap do it "creates a secret file" do expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true) expect(knife).to receive(:read_secret).and_return(secret) - rendered_template.should match(%r{#{secret}}) + expect(rendered_template).to match(%r{#{secret}}) end it "renders the client.rb with an encrypted_data_bag_secret entry" do expect(knife).to receive(:encryption_secret_provided_ignore_encrypt_flag?).and_return(true) expect(knife).to receive(:read_secret).and_return(secret) - rendered_template.should match(%r{encrypted_data_bag_secret\s*"/etc/chef/encrypted_data_bag_secret"}) + expect(rendered_template).to match(%r{encrypted_data_bag_secret\s*"/etc/chef/encrypted_data_bag_secret"}) end end @@ -322,8 +322,8 @@ describe Chef::Knife::Bootstrap do before do Chef::Config[:trusted_certs_dir] = trusted_certs_dir - IO.stub(:read).and_call_original - IO.stub(:read).with(File.expand_path(Chef::Config[:validation_key])).and_return("") + allow(IO).to receive(:read).and_call_original + allow(IO).to receive(:read).with(File.expand_path(Chef::Config[:validation_key])).and_return("") end def certificates @@ -331,22 +331,22 @@ describe Chef::Knife::Bootstrap do end it "creates /etc/chef/trusted_certs" do - rendered_template.should match(%r{mkdir -p /etc/chef/trusted_certs}) + expect(rendered_template).to match(%r{mkdir -p /etc/chef/trusted_certs}) end it "copies the certificates in the directory" do certificates.each do |cert| - IO.should_receive(:read).with(File.expand_path(cert)) + expect(IO).to receive(:read).with(File.expand_path(cert)) end certificates.each do |cert| - rendered_template.should match(%r{cat > /etc/chef/trusted_certs/#{File.basename(cert)} <<'EOP'}) + expect(rendered_template).to match(%r{cat > /etc/chef/trusted_certs/#{File.basename(cert)} <<'EOP'}) end end it "doesn't create /etc/chef/trusted_certs if :trusted_certs_dir is empty" do - Dir.should_receive(:glob).with(File.join(trusted_certs_dir, "*.{crt,pem}")).and_return([]) - rendered_template.should_not match(%r{mkdir -p /etc/chef/trusted_certs}) + expect(Dir).to receive(:glob).with(File.join(trusted_certs_dir, "*.{crt,pem}")).and_return([]) + expect(rendered_template).not_to match(%r{mkdir -p /etc/chef/trusted_certs}) end end @@ -361,57 +361,57 @@ describe Chef::Knife::Bootstrap do Chef::Config[:knife][:ssh_port] = nil knife.config[:forward_agent] = true knife.config[:identity_file] = "~/.ssh/me.rsa" - knife.stub(:render_template).and_return("") + allow(knife).to receive(:render_template).and_return("") knife.knife_ssh end it "configures the hostname" do - knife_ssh.name_args.first.should == "foo.example.com" + expect(knife_ssh.name_args.first).to eq("foo.example.com") end it "configures the ssh user" do - knife_ssh.config[:ssh_user].should == 'rooty' + expect(knife_ssh.config[:ssh_user]).to eq('rooty') end it "configures the ssh password" do - knife_ssh.config[:ssh_password].should == 'open_sesame' + expect(knife_ssh.config[:ssh_password]).to eq('open_sesame') end it "configures the ssh port" do - knife_ssh.config[:ssh_port].should == '4001' + expect(knife_ssh.config[:ssh_port]).to eq('4001') end it "configures the ssh agent forwarding" do - knife_ssh.config[:forward_agent].should == true + expect(knife_ssh.config[:forward_agent]).to eq(true) end it "configures the ssh identity file" do - knife_ssh.config[:identity_file].should == '~/.ssh/me.rsa' + expect(knife_ssh.config[:identity_file]).to eq('~/.ssh/me.rsa') end end context "validating use_sudo_password" do before do knife.config[:ssh_password] = "password" - knife.stub(:render_template).and_return("") + allow(knife).to receive(:render_template).and_return("") end it "use_sudo_password contains description and long params for help" do - knife.options.should have_key(:use_sudo_password) \ - and knife.options[:use_sudo_password][:description].to_s.should_not == ''\ - and knife.options[:use_sudo_password][:long].to_s.should_not == '' + expect(knife.options).to have_key(:use_sudo_password) \ + and expect(knife.options[:use_sudo_password][:description].to_s).not_to eq('')\ + and expect(knife.options[:use_sudo_password][:long].to_s).not_to eq('') end it "uses the password from --ssh-password for sudo when --use-sudo-password is set" do knife.config[:use_sudo] = true knife.config[:use_sudo_password] = true - knife.ssh_command.should include("echo \'#{knife.config[:ssh_password]}\' | sudo -S") + expect(knife.ssh_command).to include("echo \'#{knife.config[:ssh_password]}\' | sudo -S") end it "should not honor --use-sudo-password when --use-sudo is not set" do knife.config[:use_sudo] = false knife.config[:use_sudo_password] = true - knife.ssh_command.should_not include("echo #{knife.config[:ssh_password]} | sudo -S") + expect(knife.ssh_command).not_to include("echo #{knife.config[:ssh_password]} | sudo -S") end end @@ -424,34 +424,34 @@ describe Chef::Knife::Bootstrap do Chef::Config[:knife][:identity_file] = "~/.ssh/you.rsa" Chef::Config[:knife][:ssh_gateway] = "towel.blinkenlights.nl" Chef::Config[:knife][:host_key_verify] = true - knife.stub(:render_template).and_return("") + allow(knife).to receive(:render_template).and_return("") knife.config = {} knife.merge_configs knife.knife_ssh end it "configures the ssh user" do - knife_ssh.config[:ssh_user].should == 'curiosity' + expect(knife_ssh.config[:ssh_user]).to eq('curiosity') end it "configures the ssh port" do - knife_ssh.config[:ssh_port].should == '2430' + expect(knife_ssh.config[:ssh_port]).to eq('2430') end it "configures the ssh agent forwarding" do - knife_ssh.config[:forward_agent].should == true + expect(knife_ssh.config[:forward_agent]).to eq(true) end it "configures the ssh identity file" do - knife_ssh.config[:identity_file].should == '~/.ssh/you.rsa' + expect(knife_ssh.config[:identity_file]).to eq('~/.ssh/you.rsa') end it "configures the ssh gateway" do - knife_ssh.config[:ssh_gateway].should == 'towel.blinkenlights.nl' + expect(knife_ssh.config[:ssh_gateway]).to eq('towel.blinkenlights.nl') end it "configures the host key verify mode" do - knife_ssh.config[:host_key_verify].should == true + expect(knife_ssh.config[:host_key_verify]).to eq(true) end end @@ -460,27 +460,27 @@ describe Chef::Knife::Bootstrap do knife.name_args = ["foo.example.com"] knife.config[:ssh_user] = "rooty" knife.config[:identity_file] = "~/.ssh/me.rsa" - knife.stub(:render_template).and_return("") + allow(knife).to receive(:render_template).and_return("") k = knife.knife_ssh - k.stub(:get_password).and_return('typed_in_password') - knife.stub(:knife_ssh).and_return(k) + allow(k).to receive(:get_password).and_return('typed_in_password') + allow(knife).to receive(:knife_ssh).and_return(k) knife.knife_ssh_with_password_auth end it "prompts the user for a password " do - knife_ssh_with_password_auth.config[:ssh_password].should == 'typed_in_password' + expect(knife_ssh_with_password_auth.config[:ssh_password]).to eq('typed_in_password') end it "configures knife not to use the identity file that didn't work previously" do - knife_ssh_with_password_auth.config[:identity_file].should be_nil + expect(knife_ssh_with_password_auth.config[:identity_file]).to be_nil end end end it "verifies that a server to bootstrap was given as a command line arg" do knife.name_args = nil - lambda { knife.run }.should raise_error(SystemExit) - stderr.string.should match /ERROR:.+FQDN or ip/ + expect { knife.run }.to raise_error(SystemExit) + expect(stderr.string).to match /ERROR:.+FQDN or ip/ end describe "when running the bootstrap" do @@ -488,31 +488,31 @@ describe Chef::Knife::Bootstrap do knife.name_args = ["foo.example.com"] knife.config[:ssh_user] = "rooty" knife.config[:identity_file] = "~/.ssh/me.rsa" - knife.stub(:render_template).and_return("") + allow(knife).to receive(:render_template).and_return("") knife_ssh = knife.knife_ssh - knife.stub(:knife_ssh).and_return(knife_ssh) + allow(knife).to receive(:knife_ssh).and_return(knife_ssh) knife_ssh end it "configures the underlying ssh command and then runs it" do - knife_ssh.should_receive(:run) + expect(knife_ssh).to receive(:run) knife.run end it "falls back to password based auth when auth fails the first time" do - knife.stub(:puts) + allow(knife).to receive(:puts) fallback_knife_ssh = knife_ssh.dup - knife_ssh.should_receive(:run).and_raise(Net::SSH::AuthenticationFailed.new("no ssh for you")) - knife.stub(:knife_ssh_with_password_auth).and_return(fallback_knife_ssh) - fallback_knife_ssh.should_receive(:run) + expect(knife_ssh).to receive(:run).and_raise(Net::SSH::AuthenticationFailed.new("no ssh for you")) + allow(knife).to receive(:knife_ssh_with_password_auth).and_return(fallback_knife_ssh) + expect(fallback_knife_ssh).to receive(:run) knife.run end it "raises the exception if config[:ssh_password] is set and an authentication exception is raised" do knife.config[:ssh_password] = "password" - knife_ssh.should_receive(:run).and_raise(Net::SSH::AuthenticationFailed) - lambda { knife.run }.should raise_error(Net::SSH::AuthenticationFailed) + expect(knife_ssh).to receive(:run).and_raise(Net::SSH::AuthenticationFailed) + expect { knife.run }.to raise_error(Net::SSH::AuthenticationFailed) end end diff --git a/spec/unit/knife/client_bulk_delete_spec.rb b/spec/unit/knife/client_bulk_delete_spec.rb index d5cfda9885..45bb4dd16c 100644 --- a/spec/unit/knife/client_bulk_delete_spec.rb +++ b/spec/unit/knife/client_bulk_delete_spec.rb @@ -28,10 +28,10 @@ describe Chef::Knife::ClientBulkDelete do k = Chef::Knife::ClientBulkDelete.new k.name_args = name_args k.config = option_args - k.ui.stub(:stdout).and_return(stdout_io) - k.ui.stub(:stderr).and_return(stderr_io) - k.ui.stub(:confirm).and_return(knife_confirm) - k.ui.stub(:confirm_without_exit).and_return(knife_confirm) + allow(k.ui).to receive(:stdout).and_return(stdout_io) + allow(k.ui).to receive(:stderr).and_return(stderr_io) + allow(k.ui).to receive(:confirm).and_return(knife_confirm) + allow(k.ui).to receive(:confirm_without_exit).and_return(knife_confirm) k } @@ -47,7 +47,7 @@ describe Chef::Knife::ClientBulkDelete do nonvalidator_client_names.each do |client_name| client = Chef::ApiClient.new() client.name(client_name) - client.stub(:destroy).and_return(true) + allow(client).to receive(:destroy).and_return(true) clients[client_name] = client end @@ -61,8 +61,8 @@ describe Chef::Knife::ClientBulkDelete do validator_client_names.each do |validator_client_name| validator_client = Chef::ApiClient.new() validator_client.name(validator_client_name) - validator_client.stub(:validator).and_return(true) - validator_client.stub(:destroy).and_return(true) + allow(validator_client).to receive(:validator).and_return(true) + allow(validator_client).to receive(:destroy).and_return(true) clients[validator_client_name] = validator_client end @@ -75,7 +75,7 @@ describe Chef::Knife::ClientBulkDelete do } before(:each) do - Chef::ApiClient.stub(:list).and_return(clients) + allow(Chef::ApiClient).to receive(:list).and_return(clients) end describe "run" do @@ -83,44 +83,44 @@ describe Chef::Knife::ClientBulkDelete do let(:name_args) { [ ] } it "should exit if the regex is not provided" do - lambda { knife.run }.should raise_error(SystemExit) + expect { knife.run }.to raise_error(SystemExit) end end describe "with any clients" do it "should get the list of the clients" do - Chef::ApiClient.should_receive(:list) + expect(Chef::ApiClient).to receive(:list) knife.run end it "should print the name of the clients" do knife.run client_names.each do |client_name| - stdout.should include(client_name) + expect(stdout).to include(client_name) end end it "should confirm you really want to delete them" do - knife.ui.should_receive(:confirm) + expect(knife.ui).to receive(:confirm) knife.run end describe "without --delete-validators" do it "should mention that validator clients wont be deleted" do knife.run - stdout.should include("Following clients are validators and will not be deleted.") + expect(stdout).to include("Following clients are validators and will not be deleted.") info = stdout.index "Following clients are validators and will not be deleted." val = stdout.index "myorg-validator" - (val > info).should be_true + expect(val > info).to be_truthy end it "should only delete nonvalidator clients" do nonvalidator_clients.each_value do |c| - c.should_receive(:destroy) + expect(c).to receive(:destroy) end validator_clients.each_value do |c| - c.should_not_receive(:destroy) + expect(c).not_to receive(:destroy) end knife.run @@ -132,18 +132,18 @@ describe Chef::Knife::ClientBulkDelete do it "should mention that validator clients will be deleted" do knife.run - stdout.should include("The following validators will be deleted") + expect(stdout).to include("The following validators will be deleted") end it "should confirm twice" do - knife.ui.should_receive(:confirm).once - knife.ui.should_receive(:confirm_without_exit).once + expect(knife.ui).to receive(:confirm).once + expect(knife.ui).to receive(:confirm_without_exit).once knife.run end it "should delete all clients" do clients.each_value do |c| - c.should_receive(:destroy) + expect(c).to receive(:destroy) end knife.run @@ -155,10 +155,10 @@ describe Chef::Knife::ClientBulkDelete do let(:name_args) { [ "^ti" ] } it "should only delete clients that match the regex" do - clients["tim"].should_receive(:destroy) - clients["stephen"].should_not_receive(:destroy) - clients["dan"].should_not_receive(:destroy) - clients["myorg-validator"].should_not_receive(:destroy) + expect(clients["tim"]).to receive(:destroy) + expect(clients["stephen"]).not_to receive(:destroy) + expect(clients["dan"]).not_to receive(:destroy) + expect(clients["myorg-validator"]).not_to receive(:destroy) knife.run end end diff --git a/spec/unit/knife/client_create_spec.rb b/spec/unit/knife/client_create_spec.rb index 59238d69ec..8e7cc4a5e3 100644 --- a/spec/unit/knife/client_create_spec.rb +++ b/spec/unit/knife/client_create_spec.rb @@ -31,53 +31,53 @@ describe Chef::Knife::ClientCreate do } @knife.name_args = [ "adam" ] @client = Chef::ApiClient.new - @client.stub(:save).and_return({ 'private_key' => '' }) - @knife.stub(:edit_data).and_return(@client) - @knife.stub(:puts) - Chef::ApiClient.stub(:new).and_return(@client) + allow(@client).to receive(:save).and_return({ 'private_key' => '' }) + allow(@knife).to receive(:edit_data).and_return(@client) + allow(@knife).to receive(:puts) + allow(Chef::ApiClient).to receive(:new).and_return(@client) @stderr = StringIO.new - @knife.ui.stub(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) end describe "run" do it "should create a new Client" do - Chef::ApiClient.should_receive(:new).and_return(@client) + expect(Chef::ApiClient).to receive(:new).and_return(@client) @knife.run - @stderr.string.should match /created client.+adam/i + expect(@stderr.string).to match /created client.+adam/i end it "should set the Client name" do - @client.should_receive(:name).with("adam") + expect(@client).to receive(:name).with("adam") @knife.run end it "by default it is not an admin" do - @client.should_receive(:admin).with(false) + expect(@client).to receive(:admin).with(false) @knife.run end it "by default it is not a validator" do - @client.should_receive(:validator).with(false) + expect(@client).to receive(:validator).with(false) @knife.run end it "should allow you to edit the data" do - @knife.should_receive(:edit_data).with(@client) + expect(@knife).to receive(:edit_data).with(@client) @knife.run end it "should save the Client" do - @client.should_receive(:save) + expect(@client).to receive(:save) @knife.run end describe "with -f or --file" do it "should write the private key to a file" do @knife.config[:file] = "/tmp/monkeypants" - @client.stub(:save).and_return({ 'private_key' => "woot" }) + allow(@client).to receive(:save).and_return({ 'private_key' => "woot" }) filehandle = double("Filehandle") - filehandle.should_receive(:print).with('woot') - File.should_receive(:open).with("/tmp/monkeypants", "w").and_yield(filehandle) + expect(filehandle).to receive(:print).with('woot') + expect(File).to receive(:open).with("/tmp/monkeypants", "w").and_yield(filehandle) @knife.run end end @@ -85,7 +85,7 @@ describe Chef::Knife::ClientCreate do describe "with -a or --admin" do it "should create an admin client" do @knife.config[:admin] = true - @client.should_receive(:admin).with(true) + expect(@client).to receive(:admin).with(true) @knife.run end end @@ -93,7 +93,7 @@ describe Chef::Knife::ClientCreate do describe "with --validator" do it "should create an validator client" do @knife.config[:validator] = true - @client.should_receive(:validator).with(true) + expect(@client).to receive(:validator).with(true) @knife.run end end diff --git a/spec/unit/knife/client_delete_spec.rb b/spec/unit/knife/client_delete_spec.rb index c7908a0934..0fb5e0bab7 100644 --- a/spec/unit/knife/client_delete_spec.rb +++ b/spec/unit/knife/client_delete_spec.rb @@ -30,52 +30,52 @@ describe Chef::Knife::ClientDelete do describe 'run' do it 'should delete the client' do - @knife.should_receive(:delete_object).with(Chef::ApiClient, 'adam', 'client') + expect(@knife).to receive(:delete_object).with(Chef::ApiClient, 'adam', 'client') @knife.run end it 'should print usage and exit when a client name is not provided' do @knife.name_args = [] - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end end describe 'with a validator' do before(:each) do - Chef::Knife::UI.stub(:confirm).and_return(true) - @knife.stub(:confirm).and_return(true) + allow(Chef::Knife::UI).to receive(:confirm).and_return(true) + allow(@knife).to receive(:confirm).and_return(true) @client = Chef::ApiClient.new - Chef::ApiClient.should_receive(:load).and_return(@client) + expect(Chef::ApiClient).to receive(:load).and_return(@client) end it 'should delete non-validator client if --delete-validators is not set' do @knife.config[:delete_validators] = false - @client.should_receive(:destroy).and_return(@client) - @knife.should_receive(:msg) + expect(@client).to receive(:destroy).and_return(@client) + expect(@knife).to receive(:msg) @knife.run end it 'should delete non-validator client if --delete-validators is set' do @knife.config[:delete_validators] = true - @client.should_receive(:destroy).and_return(@client) - @knife.should_receive(:msg) + expect(@client).to receive(:destroy).and_return(@client) + expect(@knife).to receive(:msg) @knife.run end it 'should not delete validator client if --delete-validators is not set' do @client.validator(true) - @knife.ui.should_receive(:fatal) - lambda { @knife.run}.should raise_error(SystemExit) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run}.to raise_error(SystemExit) end it 'should delete validator client if --delete-validators is set' do @knife.config[:delete_validators] = true - @client.should_receive(:destroy).and_return(@client) - @knife.should_receive(:msg) + expect(@client).to receive(:destroy).and_return(@client) + expect(@knife).to receive(:msg) @knife.run end diff --git a/spec/unit/knife/client_edit_spec.rb b/spec/unit/knife/client_edit_spec.rb index 1d7049be30..c040c5e2f2 100644 --- a/spec/unit/knife/client_edit_spec.rb +++ b/spec/unit/knife/client_edit_spec.rb @@ -26,15 +26,15 @@ describe Chef::Knife::ClientEdit do describe 'run' do it 'should edit the client' do - @knife.should_receive(:edit_object).with(Chef::ApiClient, 'adam') + expect(@knife).to receive(:edit_object).with(Chef::ApiClient, 'adam') @knife.run end it 'should print usage and exit when a client name is not provided' do @knife.name_args = [] - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end end end diff --git a/spec/unit/knife/client_list_spec.rb b/spec/unit/knife/client_list_spec.rb index c4834ad8d1..eff01da4e9 100644 --- a/spec/unit/knife/client_list_spec.rb +++ b/spec/unit/knife/client_list_spec.rb @@ -26,8 +26,8 @@ describe Chef::Knife::ClientList do describe 'run' do it 'should list the clients' do - Chef::ApiClient.should_receive(:list) - @knife.should_receive(:format_list_for_display) + expect(Chef::ApiClient).to receive(:list) + expect(@knife).to receive(:format_list_for_display) @knife.run end end diff --git a/spec/unit/knife/client_reregister_spec.rb b/spec/unit/knife/client_reregister_spec.rb index daf18d5d25..f1be4ed570 100644 --- a/spec/unit/knife/client_reregister_spec.rb +++ b/spec/unit/knife/client_reregister_spec.rb @@ -24,7 +24,7 @@ describe Chef::Knife::ClientReregister do @knife.name_args = [ 'adam' ] @client_mock = double('client_mock', :private_key => "foo_key") @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end context "when no client name is given on the command line" do @@ -33,29 +33,29 @@ describe Chef::Knife::ClientReregister do end it 'should print usage and exit when a client name is not provided' do - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end end context 'when not configured for file output' do it 'reregisters the client and prints the key' do - Chef::ApiClient.should_receive(:reregister).with('adam').and_return(@client_mock) + expect(Chef::ApiClient).to receive(:reregister).with('adam').and_return(@client_mock) @knife.run - @stdout.string.should match( /foo_key/ ) + expect(@stdout.string).to match( /foo_key/ ) end end context 'when configured for file output' do it 'should write the private key to a file' do - Chef::ApiClient.should_receive(:reregister).with('adam').and_return(@client_mock) + expect(Chef::ApiClient).to receive(:reregister).with('adam').and_return(@client_mock) @knife.config[:file] = '/tmp/monkeypants' filehandle = StringIO.new - File.should_receive(:open).with('/tmp/monkeypants', 'w').and_yield(filehandle) + expect(File).to receive(:open).with('/tmp/monkeypants', 'w').and_yield(filehandle) @knife.run - filehandle.string.should == "foo_key" + expect(filehandle.string).to eq("foo_key") end end diff --git a/spec/unit/knife/configure_client_spec.rb b/spec/unit/knife/configure_client_spec.rb index de2a5a41e5..363743f8cc 100644 --- a/spec/unit/knife/configure_client_spec.rb +++ b/spec/unit/knife/configure_client_spec.rb @@ -26,16 +26,16 @@ describe Chef::Knife::ConfigureClient do Chef::Config[:validation_key] = '/etc/chef/validation.pem' @stderr = StringIO.new - @knife.ui.stub(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) end describe 'run' do it 'should print usage and exit when a directory is not provided' do - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal).with(/must provide the directory/) - lambda { + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal).with(/must provide the directory/) + expect { @knife.run - }.should raise_error SystemExit + }.to raise_error SystemExit end describe 'when specifing a directory' do @@ -43,39 +43,39 @@ describe Chef::Knife::ConfigureClient do @knife.name_args = ['/home/bob/.chef'] @client_file = StringIO.new @validation_file = StringIO.new - File.should_receive(:open).with('/home/bob/.chef/client.rb', 'w'). + expect(File).to receive(:open).with('/home/bob/.chef/client.rb', 'w'). and_yield(@client_file) - File.should_receive(:open).with('/home/bob/.chef/validation.pem', 'w'). + expect(File).to receive(:open).with('/home/bob/.chef/validation.pem', 'w'). and_yield(@validation_file) - IO.should_receive(:read).and_return('foo_bar_baz') + expect(IO).to receive(:read).and_return('foo_bar_baz') end it 'should recursively create the directory' do - FileUtils.should_receive(:mkdir_p).with('/home/bob/.chef') + expect(FileUtils).to receive(:mkdir_p).with('/home/bob/.chef') @knife.run end it 'should write out the config file' do - FileUtils.stub(:mkdir_p) + allow(FileUtils).to receive(:mkdir_p) @knife.run - @client_file.string.should match /log_level\s+\:info/ - @client_file.string.should match /log_location\s+STDOUT/ - @client_file.string.should match /chef_server_url\s+'https\:\/\/chef\.example\.com'/ - @client_file.string.should match /validation_client_name\s+'chef-validator'/ + expect(@client_file.string).to match /log_level\s+\:info/ + expect(@client_file.string).to match /log_location\s+STDOUT/ + expect(@client_file.string).to match /chef_server_url\s+'https\:\/\/chef\.example\.com'/ + expect(@client_file.string).to match /validation_client_name\s+'chef-validator'/ end it 'should write out the validation.pem file' do - FileUtils.stub(:mkdir_p) + allow(FileUtils).to receive(:mkdir_p) @knife.run - @validation_file.string.should match /foo_bar_baz/ + expect(@validation_file.string).to match /foo_bar_baz/ end it 'should print information on what is being configured' do - FileUtils.stub(:mkdir_p) + allow(FileUtils).to receive(:mkdir_p) @knife.run - @stderr.string.should match /creating client configuration/i - @stderr.string.should match /writing client\.rb/i - @stderr.string.should match /writing validation\.pem/i + expect(@stderr.string).to match /creating client configuration/i + expect(@stderr.string).to match /writing client\.rb/i + expect(@stderr.string).to match /writing validation\.pem/i end end end diff --git a/spec/unit/knife/configure_spec.rb b/spec/unit/knife/configure_spec.rb index c16019dcf7..e3ea1f052c 100644 --- a/spec/unit/knife/configure_spec.rb +++ b/spec/unit/knife/configure_spec.rb @@ -7,19 +7,19 @@ describe Chef::Knife::Configure do Chef::Config[:node_name] = "webmonkey.example.com" @knife = Chef::Knife::Configure.new @rest_client = double("null rest client", :post_rest => { :result => :true }) - @knife.stub(:rest).and_return(@rest_client) + allow(@knife).to receive(:rest).and_return(@rest_client) @out = StringIO.new - @knife.ui.stub(:stdout).and_return(@out) + allow(@knife.ui).to receive(:stdout).and_return(@out) @knife.config[:config_file] = '/home/you/.chef/knife.rb' @in = StringIO.new("\n" * 7) - @knife.ui.stub(:stdin).and_return(@in) + allow(@knife.ui).to receive(:stdin).and_return(@in) @err = StringIO.new - @knife.ui.stub(:stderr).and_return(@err) + allow(@knife.ui).to receive(:stderr).and_return(@err) - Ohai::System.stub(:new).and_return(ohai) + allow(Ohai::System).to receive(:new).and_return(ohai) end @@ -27,8 +27,8 @@ describe Chef::Knife::Configure do let(:ohai) do o = {} - o.stub(:require_plugin) - o.stub(:load_plugins) + allow(o).to receive(:require_plugin) + allow(o).to receive(:load_plugins) o[:fqdn] = fqdn o end @@ -44,63 +44,63 @@ describe Chef::Knife::Configure do it "asks the user for the URL of the chef server" do @knife.ask_user_for_config - @out.string.should match(Regexp.escape("Please enter the chef server URL: [#{default_server_url}]")) - @knife.chef_server.should == default_server_url + expect(@out.string).to match(Regexp.escape("Please enter the chef server URL: [#{default_server_url}]")) + expect(@knife.chef_server).to eq(default_server_url) end it "asks the user for the clientname they want for the new client if -i is specified" do @knife.config[:initial] = true - Etc.stub(:getlogin).and_return("a-new-user") + allow(Etc).to receive(:getlogin).and_return("a-new-user") @knife.ask_user_for_config - @out.string.should match(Regexp.escape("Please enter a name for the new user: [a-new-user]")) - @knife.new_client_name.should == Etc.getlogin + expect(@out.string).to match(Regexp.escape("Please enter a name for the new user: [a-new-user]")) + expect(@knife.new_client_name).to eq(Etc.getlogin) end it "should not ask the user for the clientname they want for the new client if -i and --node_name are specified" do @knife.config[:initial] = true @knife.config[:node_name] = 'testnode' - Etc.stub(:getlogin).and_return("a-new-user") + allow(Etc).to receive(:getlogin).and_return("a-new-user") @knife.ask_user_for_config - @out.string.should_not match(Regexp.escape("Please enter a name for the new user")) - @knife.new_client_name.should == 'testnode' + expect(@out.string).not_to match(Regexp.escape("Please enter a name for the new user")) + expect(@knife.new_client_name).to eq('testnode') end it "asks the user for the existing API username or clientname if -i is not specified" do - Etc.stub(:getlogin).and_return("a-new-user") + allow(Etc).to receive(:getlogin).and_return("a-new-user") @knife.ask_user_for_config - @out.string.should match(Regexp.escape("Please enter an existing username or clientname for the API: [a-new-user]")) - @knife.new_client_name.should == Etc.getlogin + expect(@out.string).to match(Regexp.escape("Please enter an existing username or clientname for the API: [a-new-user]")) + expect(@knife.new_client_name).to eq(Etc.getlogin) end it "asks the user for the existing admin client's name if -i is specified" do @knife.config[:initial] = true @knife.ask_user_for_config - @out.string.should match(Regexp.escape("Please enter the existing admin name: [admin]")) - @knife.admin_client_name.should == 'admin' + expect(@out.string).to match(Regexp.escape("Please enter the existing admin name: [admin]")) + expect(@knife.admin_client_name).to eq('admin') end it "should not ask the user for the existing admin client's name if -i and --admin-client_name are specified" do @knife.config[:initial] = true @knife.config[:admin_client_name] = 'my-webui' @knife.ask_user_for_config - @out.string.should_not match(Regexp.escape("Please enter the existing admin:")) - @knife.admin_client_name.should == 'my-webui' + expect(@out.string).not_to match(Regexp.escape("Please enter the existing admin:")) + expect(@knife.admin_client_name).to eq('my-webui') end it "should not ask the user for the existing admin client's name if -i is not specified" do @knife.ask_user_for_config - @out.string.should_not match(Regexp.escape("Please enter the existing admin: [admin]")) - @knife.admin_client_name.should_not == 'admin' + expect(@out.string).not_to match(Regexp.escape("Please enter the existing admin: [admin]")) + expect(@knife.admin_client_name).not_to eq('admin') end it "asks the user for the location of the existing admin key if -i is specified" do @knife.config[:initial] = true @knife.ask_user_for_config - @out.string.should match(Regexp.escape("Please enter the location of the existing admin's private key: [#{default_admin_key}]")) + expect(@out.string).to match(Regexp.escape("Please enter the location of the existing admin's private key: [#{default_admin_key}]")) if windows? - @knife.admin_client_key.capitalize.should == default_admin_key_win32.capitalize + expect(@knife.admin_client_key.capitalize).to eq(default_admin_key_win32.capitalize) else - @knife.admin_client_key.should == default_admin_key + expect(@knife.admin_client_key).to eq(default_admin_key) end end @@ -108,61 +108,61 @@ describe Chef::Knife::Configure do @knife.config[:initial] = true @knife.config[:admin_client_key] = '/home/you/.chef/my-webui.pem' @knife.ask_user_for_config - @out.string.should_not match(Regexp.escape("Please enter the location of the existing admin client's private key:")) + expect(@out.string).not_to match(Regexp.escape("Please enter the location of the existing admin client's private key:")) if windows? - @knife.admin_client_key.should match %r{^[A-Za-z]:/home/you/\.chef/my-webui\.pem$} + expect(@knife.admin_client_key).to match %r{^[A-Za-z]:/home/you/\.chef/my-webui\.pem$} else - @knife.admin_client_key.should == '/home/you/.chef/my-webui.pem' + expect(@knife.admin_client_key).to eq('/home/you/.chef/my-webui.pem') end end it "should not ask the user for the location of the existing admin key if -i is not specified" do @knife.ask_user_for_config - @out.string.should_not match(Regexp.escape("Please enter the location of the existing admin client's private key: [#{default_admin_key}]")) + expect(@out.string).not_to match(Regexp.escape("Please enter the location of the existing admin client's private key: [#{default_admin_key}]")) if windows? - @knife.admin_client_key.should_not == default_admin_key_win32 + expect(@knife.admin_client_key).not_to eq(default_admin_key_win32) else - @knife.admin_client_key.should_not == default_admin_key + expect(@knife.admin_client_key).not_to eq(default_admin_key) end end it "asks the user for the location of a chef repo" do @knife.ask_user_for_config - @out.string.should match(Regexp.escape("Please enter the path to a chef repository (or leave blank):")) - @knife.chef_repo.should == '' + expect(@out.string).to match(Regexp.escape("Please enter the path to a chef repository (or leave blank):")) + expect(@knife.chef_repo).to eq('') end it "asks the users for the name of the validation client" do @knife.ask_user_for_config - @out.string.should match(Regexp.escape("Please enter the validation clientname: [chef-validator]")) - @knife.validation_client_name.should == 'chef-validator' + expect(@out.string).to match(Regexp.escape("Please enter the validation clientname: [chef-validator]")) + expect(@knife.validation_client_name).to eq('chef-validator') end it "should not ask the users for the name of the validation client if --validation_client_name is specified" do @knife.config[:validation_client_name] = 'my-validator' @knife.ask_user_for_config - @out.string.should_not match(Regexp.escape("Please enter the validation clientname:")) - @knife.validation_client_name.should == 'my-validator' + expect(@out.string).not_to match(Regexp.escape("Please enter the validation clientname:")) + expect(@knife.validation_client_name).to eq('my-validator') end it "asks the users for the location of the validation key" do @knife.ask_user_for_config - @out.string.should match(Regexp.escape("Please enter the location of the validation key: [#{default_validator_key}]")) + expect(@out.string).to match(Regexp.escape("Please enter the location of the validation key: [#{default_validator_key}]")) if windows? - @knife.validation_key.capitalize.should == default_validator_key_win32.capitalize + expect(@knife.validation_key.capitalize).to eq(default_validator_key_win32.capitalize) else - @knife.validation_key.should == default_validator_key + expect(@knife.validation_key).to eq(default_validator_key) end end it "should not ask the users for the location of the validation key if --validation_key is specified" do @knife.config[:validation_key] = '/home/you/.chef/my-validation.pem' @knife.ask_user_for_config - @out.string.should_not match(Regexp.escape("Please enter the location of the validation key:")) + expect(@out.string).not_to match(Regexp.escape("Please enter the location of the validation key:")) if windows? - @knife.validation_key.should match %r{^[A-Za-z]:/home/you/\.chef/my-validation\.pem$} + expect(@knife.validation_key).to match %r{^[A-Za-z]:/home/you/\.chef/my-validation\.pem$} else - @knife.validation_key.should == '/home/you/.chef/my-validation.pem' + expect(@knife.validation_key).to eq('/home/you/.chef/my-validation.pem') end end @@ -176,68 +176,68 @@ describe Chef::Knife::Configure do @knife.config[:validation_key] = '/home/you/.chef/my-validation.pem' @knife.config[:repository] = '' @knife.config[:client_key] = '/home/you/a-new-user.pem' - Etc.stub(:getlogin).and_return('a-new-user') + allow(Etc).to receive(:getlogin).and_return('a-new-user') @knife.ask_user_for_config - @out.string.should match(/\s*/) + expect(@out.string).to match(/\s*/) - @knife.new_client_name.should == 'testnode' - @knife.chef_server.should == 'http://localhost:5000' - @knife.admin_client_name.should == 'my-webui' + expect(@knife.new_client_name).to eq('testnode') + expect(@knife.chef_server).to eq('http://localhost:5000') + expect(@knife.admin_client_name).to eq('my-webui') if windows? - @knife.admin_client_key.should match %r{^[A-Za-z]:/home/you/\.chef/my-webui\.pem$} - @knife.validation_key.should match %r{^[A-Za-z]:/home/you/\.chef/my-validation\.pem$} - @knife.new_client_key.should match %r{^[A-Za-z]:/home/you/a-new-user\.pem$} + expect(@knife.admin_client_key).to match %r{^[A-Za-z]:/home/you/\.chef/my-webui\.pem$} + expect(@knife.validation_key).to match %r{^[A-Za-z]:/home/you/\.chef/my-validation\.pem$} + expect(@knife.new_client_key).to match %r{^[A-Za-z]:/home/you/a-new-user\.pem$} else - @knife.admin_client_key.should == '/home/you/.chef/my-webui.pem' - @knife.validation_key.should == '/home/you/.chef/my-validation.pem' - @knife.new_client_key.should == '/home/you/a-new-user.pem' + expect(@knife.admin_client_key).to eq('/home/you/.chef/my-webui.pem') + expect(@knife.validation_key).to eq('/home/you/.chef/my-validation.pem') + expect(@knife.new_client_key).to eq('/home/you/a-new-user.pem') end - @knife.validation_client_name.should == 'my-validator' - @knife.chef_repo.should == '' + expect(@knife.validation_client_name).to eq('my-validator') + expect(@knife.chef_repo).to eq('') end it "writes the new data to a config file" do - File.stub(:expand_path).with("/home/you/.chef/knife.rb").and_return("/home/you/.chef/knife.rb") - File.stub(:expand_path).with("/home/you/.chef/#{Etc.getlogin}.pem").and_return("/home/you/.chef/#{Etc.getlogin}.pem") - File.stub(:expand_path).with(default_validator_key).and_return(default_validator_key) - File.stub(:expand_path).with(default_admin_key).and_return(default_admin_key) - FileUtils.should_receive(:mkdir_p).with("/home/you/.chef") + allow(File).to receive(:expand_path).with("/home/you/.chef/knife.rb").and_return("/home/you/.chef/knife.rb") + allow(File).to receive(:expand_path).with("/home/you/.chef/#{Etc.getlogin}.pem").and_return("/home/you/.chef/#{Etc.getlogin}.pem") + allow(File).to receive(:expand_path).with(default_validator_key).and_return(default_validator_key) + allow(File).to receive(:expand_path).with(default_admin_key).and_return(default_admin_key) + expect(FileUtils).to receive(:mkdir_p).with("/home/you/.chef") config_file = StringIO.new - ::File.should_receive(:open).with("/home/you/.chef/knife.rb", "w").and_yield config_file + expect(::File).to receive(:open).with("/home/you/.chef/knife.rb", "w").and_yield config_file @knife.config[:repository] = '/home/you/chef-repo' @knife.run - config_file.string.should match(/^node_name[\s]+'#{Etc.getlogin}'$/) - config_file.string.should match(%r{^client_key[\s]+'/home/you/.chef/#{Etc.getlogin}.pem'$}) - config_file.string.should match(/^validation_client_name\s+'chef-validator'$/) - config_file.string.should match(%r{^validation_key\s+'#{default_validator_key}'$}) - config_file.string.should match(%r{^chef_server_url\s+'#{default_server_url}'$}) - config_file.string.should match(%r{cookbook_path\s+\[ '/home/you/chef-repo/cookbooks' \]}) + expect(config_file.string).to match(/^node_name[\s]+'#{Etc.getlogin}'$/) + expect(config_file.string).to match(%r{^client_key[\s]+'/home/you/.chef/#{Etc.getlogin}.pem'$}) + expect(config_file.string).to match(/^validation_client_name\s+'chef-validator'$/) + expect(config_file.string).to match(%r{^validation_key\s+'#{default_validator_key}'$}) + expect(config_file.string).to match(%r{^chef_server_url\s+'#{default_server_url}'$}) + expect(config_file.string).to match(%r{cookbook_path\s+\[ '/home/you/chef-repo/cookbooks' \]}) end it "creates a new client when given the --initial option" do - File.should_receive(:expand_path).with("/home/you/.chef/knife.rb").and_return("/home/you/.chef/knife.rb") - File.should_receive(:expand_path).with("/home/you/.chef/a-new-user.pem").and_return("/home/you/.chef/a-new-user.pem") - File.should_receive(:expand_path).with(default_validator_key).and_return(default_validator_key) - File.should_receive(:expand_path).with(default_admin_key).and_return(default_admin_key) + expect(File).to receive(:expand_path).with("/home/you/.chef/knife.rb").and_return("/home/you/.chef/knife.rb") + expect(File).to receive(:expand_path).with("/home/you/.chef/a-new-user.pem").and_return("/home/you/.chef/a-new-user.pem") + expect(File).to receive(:expand_path).with(default_validator_key).and_return(default_validator_key) + expect(File).to receive(:expand_path).with(default_admin_key).and_return(default_admin_key) Chef::Config[:node_name] = "webmonkey.example.com" user_command = Chef::Knife::UserCreate.new - user_command.should_receive(:run) + expect(user_command).to receive(:run) - Etc.stub(:getlogin).and_return("a-new-user") + allow(Etc).to receive(:getlogin).and_return("a-new-user") - Chef::Knife::UserCreate.stub(:new).and_return(user_command) - FileUtils.should_receive(:mkdir_p).with("/home/you/.chef") - ::File.should_receive(:open).with("/home/you/.chef/knife.rb", "w") + allow(Chef::Knife::UserCreate).to receive(:new).and_return(user_command) + expect(FileUtils).to receive(:mkdir_p).with("/home/you/.chef") + expect(::File).to receive(:open).with("/home/you/.chef/knife.rb", "w") @knife.config[:initial] = true @knife.config[:user_password] = "blah" @knife.run - user_command.name_args.should == Array("a-new-user") - user_command.config[:user_password].should == "blah" - user_command.config[:admin].should be_true - user_command.config[:file].should == "/home/you/.chef/a-new-user.pem" - user_command.config[:yes].should be_true - user_command.config[:disable_editing].should be_true + expect(user_command.name_args).to eq(Array("a-new-user")) + expect(user_command.config[:user_password]).to eq("blah") + expect(user_command.config[:admin]).to be_truthy + expect(user_command.config[:file]).to eq("/home/you/.chef/a-new-user.pem") + expect(user_command.config[:yes]).to be_truthy + expect(user_command.config[:disable_editing]).to be_truthy end end diff --git a/spec/unit/knife/cookbook_bulk_delete_spec.rb b/spec/unit/knife/cookbook_bulk_delete_spec.rb index fb4b1d1484..98cd06bbbc 100644 --- a/spec/unit/knife/cookbook_bulk_delete_spec.rb +++ b/spec/unit/knife/cookbook_bulk_delete_spec.rb @@ -28,19 +28,19 @@ describe Chef::Knife::CookbookBulkDelete do @knife.name_args = ["."] @stdout = StringIO.new @stderr = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) - @knife.ui.stub(:stderr).and_return(@stderr) - @knife.ui.stub(:confirm).and_return(true) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:confirm).and_return(true) @cookbooks = Hash.new %w{cheezburger pizza lasagna}.each do |cookbook_name| cookbook = Chef::CookbookVersion.new(cookbook_name) @cookbooks[cookbook_name] = cookbook end @rest = double("Chef::REST") - @rest.stub(:get_rest).and_return(@cookbooks) - @rest.stub(:delete_rest).and_return(true) - @knife.stub(:rest).and_return(@rest) - Chef::CookbookVersion.stub(:list).and_return(@cookbooks) + allow(@rest).to receive(:get_rest).and_return(@cookbooks) + allow(@rest).to receive(:delete_rest).and_return(true) + allow(@knife).to receive(:rest).and_return(@rest) + allow(Chef::CookbookVersion).to receive(:list).and_return(@cookbooks) end @@ -49,41 +49,41 @@ describe Chef::Knife::CookbookBulkDelete do describe "when there are several cookbooks on the server" do before do @cheezburger = {'cheezburger' => {"url" => "file:///dev/null", "versions" => [{"url" => "file:///dev/null-cheez", "version" => "1.0.0"}]}} - @rest.stub(:get_rest).with('cookbooks/cheezburger').and_return(@cheezburger) + allow(@rest).to receive(:get_rest).with('cookbooks/cheezburger').and_return(@cheezburger) @pizza = {'pizza' => {"url" => "file:///dev/null", "versions" => [{"url" => "file:///dev/null-pizza", "version" => "2.0.0"}]}} - @rest.stub(:get_rest).with('cookbooks/pizza').and_return(@pizza) + allow(@rest).to receive(:get_rest).with('cookbooks/pizza').and_return(@pizza) @lasagna = {'lasagna' => {"url" => "file:///dev/null", "versions" => [{"url" => "file:///dev/null-lasagna", "version" => "3.0.0"}]}} - @rest.stub(:get_rest).with('cookbooks/lasagna').and_return(@lasagna) + allow(@rest).to receive(:get_rest).with('cookbooks/lasagna').and_return(@lasagna) end it "should print the cookbooks you are about to delete" do expected = @knife.ui.list(@cookbooks.keys.sort, :columns_down) @knife.run - @stdout.string.should match(/#{expected}/) + expect(@stdout.string).to match(/#{expected}/) end it "should confirm you really want to delete them" do - @knife.ui.should_receive(:confirm) + expect(@knife.ui).to receive(:confirm) @knife.run end it "should delete each cookbook" do {"cheezburger" => "1.0.0", "pizza" => "2.0.0", "lasagna" => '3.0.0'}.each do |cookbook_name, version| - @rest.should_receive(:delete_rest).with("cookbooks/#{cookbook_name}/#{version}") + expect(@rest).to receive(:delete_rest).with("cookbooks/#{cookbook_name}/#{version}") end @knife.run end it "should only delete cookbooks that match the regex" do @knife.name_args = ["cheezburger"] - @rest.should_receive(:delete_rest).with('cookbooks/cheezburger/1.0.0') + expect(@rest).to receive(:delete_rest).with('cookbooks/cheezburger/1.0.0') @knife.run end end it "should exit if the regex is not provided" do @knife.name_args = [] - lambda { @knife.run }.should raise_error(SystemExit) + expect { @knife.run }.to raise_error(SystemExit) end end diff --git a/spec/unit/knife/cookbook_create_spec.rb b/spec/unit/knife/cookbook_create_spec.rb index 06475d3ac9..3354432d39 100644 --- a/spec/unit/knife/cookbook_create_spec.rb +++ b/spec/unit/knife/cookbook_create_spec.rb @@ -26,29 +26,29 @@ describe Chef::Knife::CookbookCreate do @knife.config = {} @knife.name_args = ["foobar"] @stdout = StringIO.new - @knife.stub(:stdout).and_return(@stdout) + allow(@knife).to receive(:stdout).and_return(@stdout) end describe "run" do # Fixes CHEF-2579 it "should expand the path of the cookbook directory" do - File.should_receive(:expand_path).with("~/tmp/monkeypants") + expect(File).to receive(:expand_path).with("~/tmp/monkeypants") @knife.config = {:cookbook_path => "~/tmp/monkeypants"} - @knife.stub(:create_cookbook) - @knife.stub(:create_readme) - @knife.stub(:create_changelog) - @knife.stub(:create_metadata) + allow(@knife).to receive(:create_cookbook) + allow(@knife).to receive(:create_readme) + allow(@knife).to receive(:create_changelog) + allow(@knife).to receive(:create_metadata) @knife.run end it "should create a new cookbook with default values to copyright name, email, readme format and license if those are not supplied" do @dir = Dir.tmpdir @knife.config = {:cookbook_path => @dir} - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "YOUR_COMPANY_NAME", "none") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "md") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "YOUR_COMPANY_NAME", "YOUR_EMAIL", "none", "md") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "YOUR_COMPANY_NAME", "none") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "md") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "YOUR_COMPANY_NAME", "YOUR_EMAIL", "none", "md") @knife.run end @@ -59,10 +59,10 @@ describe Chef::Knife::CookbookCreate do :cookbook_copyright => "Opscode, Inc" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "none") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "md") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "YOUR_EMAIL", "none", "md") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "none") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "md") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "YOUR_EMAIL", "none", "md") @knife.run end @@ -74,10 +74,10 @@ describe Chef::Knife::CookbookCreate do :cookbook_email => "nuo@opscode.com" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "none") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "md") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "none", "md") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "none") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "md") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "none", "md") @knife.run end @@ -90,10 +90,10 @@ describe Chef::Knife::CookbookCreate do :cookbook_license => "apachev2" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "apachev2") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "md") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "apachev2", "md") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "apachev2") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "md") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "apachev2", "md") @knife.run end @@ -106,10 +106,10 @@ describe Chef::Knife::CookbookCreate do :cookbook_license => false } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "none") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "md") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "none", "md") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "none") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "md") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "none", "md") @knife.run end @@ -122,10 +122,10 @@ describe Chef::Knife::CookbookCreate do :cookbook_license => "false" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "none") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "md") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "none", "md") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "none") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "md") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "none", "md") @knife.run end @@ -138,10 +138,10 @@ describe Chef::Knife::CookbookCreate do :cookbook_license => "gplv2" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "gplv2") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "md") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "gplv2", "md") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "gplv2") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "md") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "gplv2", "md") @knife.run end @@ -154,10 +154,10 @@ describe Chef::Knife::CookbookCreate do :cookbook_license => "gplv3" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "gplv3") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "md") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "gplv3", "md") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "gplv3") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "md") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "gplv3", "md") @knife.run end @@ -170,10 +170,10 @@ describe Chef::Knife::CookbookCreate do :cookbook_license => "mit" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "mit") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "md") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "mit", "md") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "mit") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "md") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "mit", "md") @knife.run end @@ -187,10 +187,10 @@ describe Chef::Knife::CookbookCreate do :readme_format => "rdoc" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "mit") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "rdoc") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "mit", "rdoc") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "mit") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "rdoc") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "mit", "rdoc") @knife.run end @@ -204,10 +204,10 @@ describe Chef::Knife::CookbookCreate do :readme_format => "mkd" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "mit") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "mkd") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "mit", "mkd") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "mit") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "mkd") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "mit", "mkd") @knife.run end @@ -221,10 +221,10 @@ describe Chef::Knife::CookbookCreate do :readme_format => "txt" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "mit") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "txt") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "mit", "txt") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "mit") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "txt") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "mit", "txt") @knife.run end @@ -238,10 +238,10 @@ describe Chef::Knife::CookbookCreate do :readme_format => "foo" } @knife.name_args=["foobar"] - @knife.should_receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "mit") - @knife.should_receive(:create_readme).with(@dir, @knife.name_args.first, "foo") - @knife.should_receive(:create_changelog).with(@dir, @knife.name_args.first) - @knife.should_receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "mit", "foo") + expect(@knife).to receive(:create_cookbook).with(@dir, @knife.name_args.first, "Opscode, Inc", "mit") + expect(@knife).to receive(:create_readme).with(@dir, @knife.name_args.first, "foo") + expect(@knife).to receive(:create_changelog).with(@dir, @knife.name_args.first) + expect(@knife).to receive(:create_metadata).with(@dir, @knife.name_args.first, "Opscode, Inc", "nuo@opscode.com", "mit", "foo") @knife.run end @@ -252,7 +252,7 @@ describe Chef::Knife::CookbookCreate do it "should throw an argument error" do @dir = Dir.tmpdir - lambda{@knife.run}.should raise_error(ArgumentError) + expect{@knife.run}.to raise_error(ArgumentError) end end diff --git a/spec/unit/knife/cookbook_delete_spec.rb b/spec/unit/knife/cookbook_delete_spec.rb index 53b120be71..4e75a689e3 100644 --- a/spec/unit/knife/cookbook_delete_spec.rb +++ b/spec/unit/knife/cookbook_delete_spec.rb @@ -24,29 +24,29 @@ describe Chef::Knife::CookbookDelete do @knife.name_args = ['foobar'] @knife.cookbook_name = 'foobar' @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) @stderr = StringIO.new - @knife.ui.stub(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) end describe 'run' do it 'should print usage and exit when a cookbook name is not provided' do @knife.name_args = [] - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end describe 'when specifying a cookbook name' do it 'should delete the cookbook without a specific version' do - @knife.should_receive(:delete_without_explicit_version) + expect(@knife).to receive(:delete_without_explicit_version) @knife.run end describe 'and a version' do it 'should delete the specific version of the cookbook' do @knife.name_args << '1.0.0' - @knife.should_receive(:delete_explicit_version) + expect(@knife).to receive(:delete_explicit_version) @knife.run end end @@ -54,7 +54,7 @@ describe Chef::Knife::CookbookDelete do describe 'with -a or --all' do it 'should delete all versions of the cookbook' do @knife.config[:all] = true - @knife.should_receive(:delete_all_versions) + expect(@knife).to receive(:delete_all_versions) @knife.run end end @@ -62,9 +62,9 @@ describe Chef::Knife::CookbookDelete do describe 'with -p or --purge' do it 'should prompt to purge the files' do @knife.config[:purge] = true - @knife.should_receive(:confirm). + expect(@knife).to receive(:confirm). with(/.+Are you sure you want to purge files.+/) - @knife.should_receive(:delete_without_explicit_version) + expect(@knife).to receive(:delete_without_explicit_version) @knife.run end end @@ -75,10 +75,10 @@ describe Chef::Knife::CookbookDelete do it 'should delete the specific cookbook version' do @knife.cookbook_name = 'foobar' @knife.version = '1.0.0' - @knife.should_receive(:delete_object).with(Chef::CookbookVersion, + expect(@knife).to receive(:delete_object).with(Chef::CookbookVersion, 'foobar version 1.0.0', 'cookbook').and_yield() - @knife.should_receive(:delete_request).with('cookbooks/foobar/1.0.0') + expect(@knife).to receive(:delete_request).with('cookbooks/foobar/1.0.0') @knife.delete_explicit_version end end @@ -86,8 +86,8 @@ describe Chef::Knife::CookbookDelete do describe 'delete_all_versions' do it 'should prompt to delete all versions of the cookbook' do @knife.cookbook_name = 'foobar' - @knife.should_receive(:confirm).with('Do you really want to delete all versions of foobar') - @knife.should_receive(:delete_all_without_confirmation) + expect(@knife).to receive(:confirm).with('Do you really want to delete all versions of foobar') + expect(@knife).to receive(:delete_all_without_confirmation) @knife.delete_all_versions end end @@ -95,9 +95,9 @@ describe Chef::Knife::CookbookDelete do describe 'delete_all_without_confirmation' do it 'should delete all versions without confirmation' do versions = ['1.0.0', '1.1.0'] - @knife.should_receive(:available_versions).and_return(versions) + expect(@knife).to receive(:available_versions).and_return(versions) versions.each do |v| - @knife.should_receive(:delete_version_without_confirmation).with(v) + expect(@knife).to receive(:delete_version_without_confirmation).with(v) end @knife.delete_all_without_confirmation end @@ -105,20 +105,20 @@ describe Chef::Knife::CookbookDelete do describe 'delete_without_explicit_version' do it 'should exit if there are no available versions' do - @knife.should_receive(:available_versions).and_return(nil) - lambda { @knife.delete_without_explicit_version }.should raise_error(SystemExit) + expect(@knife).to receive(:available_versions).and_return(nil) + expect { @knife.delete_without_explicit_version }.to raise_error(SystemExit) end it 'should delete the version if only one is found' do - @knife.should_receive(:available_versions).at_least(:once).and_return(['1.0.0']) - @knife.should_receive(:delete_explicit_version) + expect(@knife).to receive(:available_versions).at_least(:once).and_return(['1.0.0']) + expect(@knife).to receive(:delete_explicit_version) @knife.delete_without_explicit_version end it 'should ask which version(s) to delete if multiple are found' do - @knife.should_receive(:available_versions).at_least(:once).and_return(['1.0.0', '1.1.0']) - @knife.should_receive(:ask_which_versions_to_delete).and_return(['1.0.0', '1.1.0']) - @knife.should_receive(:delete_versions_without_confirmation).with(['1.0.0', '1.1.0']) + expect(@knife).to receive(:available_versions).at_least(:once).and_return(['1.0.0', '1.1.0']) + expect(@knife).to receive(:ask_which_versions_to_delete).and_return(['1.0.0', '1.1.0']) + expect(@knife).to receive(:delete_versions_without_confirmation).with(['1.0.0', '1.1.0']) @knife.delete_without_explicit_version end end @@ -126,7 +126,7 @@ describe Chef::Knife::CookbookDelete do describe 'available_versions' do before(:each) do @rest_mock = double('rest') - @knife.should_receive(:rest).and_return(@rest_mock) + expect(@knife).to receive(:rest).and_return(@rest_mock) @cookbook_data = { 'foobar' => { 'versions' => [{'version' => '1.0.0'}, {'version' => '1.1.0'}, {'version' => '2.0.0'} ]} @@ -134,85 +134,85 @@ describe Chef::Knife::CookbookDelete do end it 'should return the list of versions of the cookbook' do - @rest_mock.should_receive(:get_rest).with('cookbooks/foobar').and_return(@cookbook_data) - @knife.available_versions.should == ['1.0.0', '1.1.0', '2.0.0'] + expect(@rest_mock).to receive(:get_rest).with('cookbooks/foobar').and_return(@cookbook_data) + expect(@knife.available_versions).to eq(['1.0.0', '1.1.0', '2.0.0']) end it 'should raise if an error other than HTTP 404 is returned' do exception = Net::HTTPServerException.new('500 Internal Server Error', '500') - @rest_mock.should_receive(:get_rest).and_raise(exception) - lambda { @knife.available_versions }.should raise_error Net::HTTPServerException + expect(@rest_mock).to receive(:get_rest).and_raise(exception) + expect { @knife.available_versions }.to raise_error Net::HTTPServerException end describe "if the cookbook can't be found" do before(:each) do - @rest_mock.should_receive(:get_rest). + expect(@rest_mock).to receive(:get_rest). and_raise(Net::HTTPServerException.new('404 Not Found', '404')) end it 'should print an error' do @knife.available_versions - @stderr.string.should match /error.+cannot find a cookbook named foobar/i + expect(@stderr.string).to match /error.+cannot find a cookbook named foobar/i end it 'should return nil' do - @knife.available_versions.should == nil + expect(@knife.available_versions).to eq(nil) end end end describe 'ask_which_version_to_delete' do before(:each) do - @knife.stub(:available_versions).and_return(['1.0.0', '1.1.0', '2.0.0']) + allow(@knife).to receive(:available_versions).and_return(['1.0.0', '1.1.0', '2.0.0']) end it 'should prompt the user to select a version' do prompt = /Which version\(s\) do you want to delete\?.+1\. foobar 1\.0\.0.+2\. foobar 1\.1\.0.+3\. foobar 2\.0\.0.+4\. All versions.+/m - @knife.should_receive(:ask_question).with(prompt).and_return('1') + expect(@knife).to receive(:ask_question).with(prompt).and_return('1') @knife.ask_which_versions_to_delete end it "should print an error and exit if a version wasn't specified" do - @knife.should_receive(:ask_question).and_return('') - @knife.ui.should_receive(:error).with(/no versions specified/i) - lambda { @knife.ask_which_versions_to_delete }.should raise_error(SystemExit) + expect(@knife).to receive(:ask_question).and_return('') + expect(@knife.ui).to receive(:error).with(/no versions specified/i) + expect { @knife.ask_which_versions_to_delete }.to raise_error(SystemExit) end it 'should print an error if an invalid choice was selected' do - @knife.should_receive(:ask_question).and_return('100') - @knife.ui.should_receive(:error).with(/100 is not a valid choice/i) + expect(@knife).to receive(:ask_question).and_return('100') + expect(@knife.ui).to receive(:error).with(/100 is not a valid choice/i) @knife.ask_which_versions_to_delete end it 'should return the selected versions' do - @knife.should_receive(:ask_question).and_return('1, 3') - @knife.ask_which_versions_to_delete.should == ['1.0.0', '2.0.0'] + expect(@knife).to receive(:ask_question).and_return('1, 3') + expect(@knife.ask_which_versions_to_delete).to eq(['1.0.0', '2.0.0']) end it "should return all of the versions if 'all' was selected" do - @knife.should_receive(:ask_question).and_return('4') - @knife.ask_which_versions_to_delete.should == [:all] + expect(@knife).to receive(:ask_question).and_return('4') + expect(@knife.ask_which_versions_to_delete).to eq([:all]) end end describe 'delete_version_without_confirmation' do it 'should delete the cookbook version' do - @knife.should_receive(:delete_request).with('cookbooks/foobar/1.0.0') + expect(@knife).to receive(:delete_request).with('cookbooks/foobar/1.0.0') @knife.delete_version_without_confirmation('1.0.0') end it 'should output that the cookbook was deleted' do - @knife.stub(:delete_request) + allow(@knife).to receive(:delete_request) @knife.delete_version_without_confirmation('1.0.0') - @stderr.string.should match /deleted cookbook\[foobar\]\[1.0.0\]/im + expect(@stderr.string).to match /deleted cookbook\[foobar\]\[1.0.0\]/im end describe 'with --print-after' do it 'should display the cookbook data' do object = '' @knife.config[:print_after] = true - @knife.stub(:delete_request).and_return(object) - @knife.should_receive(:format_for_display).with(object) + allow(@knife).to receive(:delete_request).and_return(object) + expect(@knife).to receive(:format_for_display).with(object) @knife.delete_version_without_confirmation('1.0.0') end end @@ -222,7 +222,7 @@ describe Chef::Knife::CookbookDelete do it 'should delete each version without confirmation' do versions = ['1.0.0', '1.1.0'] versions.each do |v| - @knife.should_receive(:delete_version_without_confirmation).with(v) + expect(@knife).to receive(:delete_version_without_confirmation).with(v) end @knife.delete_versions_without_confirmation(versions) end @@ -230,7 +230,7 @@ describe Chef::Knife::CookbookDelete do describe 'with -a or --all' do it 'should delete all versions without confirmation' do versions = [:all] - @knife.should_receive(:delete_all_without_confirmation) + expect(@knife).to receive(:delete_all_without_confirmation) @knife.delete_versions_without_confirmation(versions) end end diff --git a/spec/unit/knife/cookbook_download_spec.rb b/spec/unit/knife/cookbook_download_spec.rb index 6f40a3396b..7ca1adfcb5 100644 --- a/spec/unit/knife/cookbook_download_spec.rb +++ b/spec/unit/knife/cookbook_download_spec.rb @@ -22,22 +22,22 @@ describe Chef::Knife::CookbookDownload do before(:each) do @knife = Chef::Knife::CookbookDownload.new @stderr = StringIO.new - @knife.ui.stub(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) end describe 'run' do it 'should print usage and exit when a cookbook name is not provided' do @knife.name_args = [] - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal).with(/must specify a cookbook name/) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal).with(/must specify a cookbook name/) + expect { @knife.run }.to raise_error(SystemExit) end it 'should exit with a fatal error when there is no cookbook on the server' do @knife.name_args = ['foobar', nil] - @knife.should_receive(:determine_version).and_return(nil) - @knife.ui.should_receive(:fatal).with('No such cookbook found') - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:determine_version).and_return(nil) + expect(@knife.ui).to receive(:fatal).with('No such cookbook found') + expect { @knife.run }.to raise_error(SystemExit) end describe 'with a cookbook name' do @@ -45,7 +45,7 @@ describe Chef::Knife::CookbookDownload do @knife.name_args = ['foobar'] @knife.config[:download_directory] = '/var/tmp/chef' @rest_mock = double('rest') - @knife.stub(:rest).and_return(@rest_mock) + allow(@knife).to receive(:rest).and_return(@rest_mock) @manifest_data = { :recipes => [ @@ -67,17 +67,17 @@ describe Chef::Knife::CookbookDownload do } @cookbook_mock = double('cookbook') - @cookbook_mock.stub(:version).and_return('1.0.0') - @cookbook_mock.stub(:manifest).and_return(@manifest_data) - @rest_mock.should_receive(:get_rest).with('cookbooks/foobar/1.0.0'). + allow(@cookbook_mock).to receive(:version).and_return('1.0.0') + allow(@cookbook_mock).to receive(:manifest).and_return(@manifest_data) + expect(@rest_mock).to receive(:get_rest).with('cookbooks/foobar/1.0.0'). and_return(@cookbook_mock) end it 'should determine which version if one was not explicitly specified'do - @cookbook_mock.stub(:manifest).and_return({}) - @knife.should_receive(:determine_version).and_return('1.0.0') - File.should_receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(false) - Chef::CookbookVersion.stub(:COOKBOOK_SEGEMENTS).and_return([]) + allow(@cookbook_mock).to receive(:manifest).and_return({}) + expect(@knife).to receive(:determine_version).and_return('1.0.0') + expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(false) + allow(Chef::CookbookVersion).to receive(:COOKBOOK_SEGEMENTS).and_return([]) @knife.run end @@ -88,50 +88,50 @@ describe Chef::Knife::CookbookDownload do @files_mocks = {} @files.map { |f| File.basename(f) }.flatten.uniq.each do |f| @files_mocks[f] = double("#{f}_mock") - @files_mocks[f].stub(:path).and_return("/var/tmp/#{f}") + allow(@files_mocks[f]).to receive(:path).and_return("/var/tmp/#{f}") end end it 'should print an error and exit if the cookbook download directory already exists' do - File.should_receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(true) - @knife.ui.should_receive(:fatal).with(/\/var\/tmp\/chef\/foobar-1\.0\.0 exists/i) - lambda { @knife.run }.should raise_error(SystemExit) + expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(true) + expect(@knife.ui).to receive(:fatal).with(/\/var\/tmp\/chef\/foobar-1\.0\.0 exists/i) + expect { @knife.run }.to raise_error(SystemExit) end describe 'when downloading the cookbook' do before(:each) do @files.map { |f| File.dirname(f) }.flatten.uniq.each do |dir| - FileUtils.should_receive(:mkdir_p).with("/var/tmp/chef/foobar-1.0.0/#{dir}"). + expect(FileUtils).to receive(:mkdir_p).with("/var/tmp/chef/foobar-1.0.0/#{dir}"). at_least(:once) end @files_mocks.each_pair do |file, mock| - @rest_mock.should_receive(:get_rest).with("http://example.org/files/#{file}", true). + expect(@rest_mock).to receive(:get_rest).with("http://example.org/files/#{file}", true). and_return(mock) end - @rest_mock.should_receive(:sign_on_redirect=).with(false).at_least(:once) + expect(@rest_mock).to receive(:sign_on_redirect=).with(false).at_least(:once) @files.each do |f| - FileUtils.should_receive(:mv). + expect(FileUtils).to receive(:mv). with("/var/tmp/#{File.basename(f)}", "/var/tmp/chef/foobar-1.0.0/#{f}") end end it "should download the cookbook when the cookbook download directory doesn't exist" do - File.should_receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(false) + expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(false) @knife.run ['attributes', 'recipes', 'templates'].each do |segment| - @stderr.string.should match /downloading #{segment}/im + expect(@stderr.string).to match /downloading #{segment}/im end - @stderr.string.should match /downloading foobar cookbook version 1\.0\.0/im - @stderr.string.should match /cookbook downloaded to \/var\/tmp\/chef\/foobar-1\.0\.0/im + expect(@stderr.string).to match /downloading foobar cookbook version 1\.0\.0/im + expect(@stderr.string).to match /cookbook downloaded to \/var\/tmp\/chef\/foobar-1\.0\.0/im end describe 'with -f or --force' do it 'should remove the existing the cookbook download directory if it exists' do @knife.config[:force] = true - File.should_receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(true) - FileUtils.should_receive(:rm_rf).with('/var/tmp/chef/foobar-1.0.0') + expect(File).to receive(:exists?).with('/var/tmp/chef/foobar-1.0.0').and_return(true) + expect(FileUtils).to receive(:rm_rf).with('/var/tmp/chef/foobar-1.0.0') @knife.run end end @@ -145,30 +145,30 @@ describe Chef::Knife::CookbookDownload do describe 'determine_version' do it 'should return nil if there are no versions' do - @knife.should_receive(:available_versions).and_return(nil) - @knife.determine_version.should == nil - @knife.version.should == nil + expect(@knife).to receive(:available_versions).and_return(nil) + expect(@knife.determine_version).to eq(nil) + expect(@knife.version).to eq(nil) end it 'should return and set the version if there is only one version' do - @knife.should_receive(:available_versions).at_least(:once).and_return(['1.0.0']) - @knife.determine_version.should == '1.0.0' - @knife.version.should == '1.0.0' + expect(@knife).to receive(:available_versions).at_least(:once).and_return(['1.0.0']) + expect(@knife.determine_version).to eq('1.0.0') + expect(@knife.version).to eq('1.0.0') end it 'should ask which version to download and return it if there is more than one' do - @knife.should_receive(:available_versions).at_least(:once).and_return(['1.0.0', '2.0.0']) - @knife.should_receive(:ask_which_version).and_return('1.0.0') - @knife.determine_version.should == '1.0.0' + expect(@knife).to receive(:available_versions).at_least(:once).and_return(['1.0.0', '2.0.0']) + expect(@knife).to receive(:ask_which_version).and_return('1.0.0') + expect(@knife.determine_version).to eq('1.0.0') end describe 'with -N or --latest' do it 'should return and set the version to the latest version' do @knife.config[:latest] = true - @knife.should_receive(:available_versions).at_least(:once). + expect(@knife).to receive(:available_versions).at_least(:once). and_return(['1.0.0', '1.1.0', '2.0.0']) @knife.determine_version - @knife.version.to_s.should == '2.0.0' + expect(@knife.version.to_s).to eq('2.0.0') end end end @@ -179,23 +179,23 @@ describe Chef::Knife::CookbookDownload do end it 'should return nil if there are no versions' do - Chef::CookbookVersion.should_receive(:available_versions). + expect(Chef::CookbookVersion).to receive(:available_versions). with('foobar'). and_return(nil) - @knife.available_versions.should == nil + expect(@knife.available_versions).to eq(nil) end it 'should return the available versions' do - Chef::CookbookVersion.should_receive(:available_versions). + expect(Chef::CookbookVersion).to receive(:available_versions). with('foobar'). and_return(['1.1.0', '2.0.0', '1.0.0']) - @knife.available_versions.should == [Chef::Version.new('1.0.0'), + expect(@knife.available_versions).to eq([Chef::Version.new('1.0.0'), Chef::Version.new('1.1.0'), - Chef::Version.new('2.0.0')] + Chef::Version.new('2.0.0')]) end it 'should avoid multiple API calls to the server' do - Chef::CookbookVersion.should_receive(:available_versions). + expect(Chef::CookbookVersion).to receive(:available_versions). once. with('foobar'). and_return(['1.1.0', '2.0.0', '1.0.0']) @@ -207,31 +207,31 @@ describe Chef::Knife::CookbookDownload do describe 'ask_which_version' do before(:each) do @knife.cookbook_name = 'foobar' - @knife.stub(:available_versions).and_return(['1.0.0', '1.1.0', '2.0.0']) + allow(@knife).to receive(:available_versions).and_return(['1.0.0', '1.1.0', '2.0.0']) end it 'should prompt the user to select a version' do prompt = /Which version do you want to download\?.+1\. foobar 1\.0\.0.+2\. foobar 1\.1\.0.+3\. foobar 2\.0\.0.+/m - @knife.should_receive(:ask_question).with(prompt).and_return('1') + expect(@knife).to receive(:ask_question).with(prompt).and_return('1') @knife.ask_which_version end it "should set the version to the user's selection" do - @knife.should_receive(:ask_question).and_return('1') + expect(@knife).to receive(:ask_question).and_return('1') @knife.ask_which_version - @knife.version.should == '1.0.0' + expect(@knife.version).to eq('1.0.0') end it "should print an error and exit if a version wasn't specified" do - @knife.should_receive(:ask_question).and_return('') - @knife.ui.should_receive(:error).with(/is not a valid value/i) - lambda { @knife.ask_which_version }.should raise_error(SystemExit) + expect(@knife).to receive(:ask_question).and_return('') + expect(@knife.ui).to receive(:error).with(/is not a valid value/i) + expect { @knife.ask_which_version }.to raise_error(SystemExit) end it 'should print an error if an invalid choice was selected' do - @knife.should_receive(:ask_question).and_return('100') - @knife.ui.should_receive(:error).with(/'100' is not a valid value/i) - lambda { @knife.ask_which_version }.should raise_error(SystemExit) + expect(@knife).to receive(:ask_question).and_return('100') + expect(@knife.ui).to receive(:error).with(/'100' is not a valid value/i) + expect { @knife.ask_which_version }.to raise_error(SystemExit) end end diff --git a/spec/unit/knife/cookbook_list_spec.rb b/spec/unit/knife/cookbook_list_spec.rb index 9ff16edb37..559f700bb4 100644 --- a/spec/unit/knife/cookbook_list_spec.rb +++ b/spec/unit/knife/cookbook_list_spec.rb @@ -22,7 +22,7 @@ describe Chef::Knife::CookbookList do before do @knife = Chef::Knife::CookbookList.new @rest_mock = double('rest') - @knife.stub(:rest).and_return(@rest_mock) + allow(@knife).to receive(:rest).and_return(@rest_mock) @cookbook_names = ['apache2', 'mysql'] @base_url = 'https://server.example.com/cookbooks' @cookbook_data = {} @@ -32,22 +32,22 @@ describe Chef::Knife::CookbookList do 'url' => "#{@base_url}/#{item}/1.0.1"}]} end @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe 'run' do it 'should display the latest version of the cookbooks' do - @rest_mock.should_receive(:get_rest).with('/cookbooks?num_versions=1'). + expect(@rest_mock).to receive(:get_rest).with('/cookbooks?num_versions=1'). and_return(@cookbook_data) @knife.run @cookbook_names.each do |item| - @stdout.string.should match /#{item}\s+1\.0\.1/ + expect(@stdout.string).to match /#{item}\s+1\.0\.1/ end end it 'should query cookbooks for the configured environment' do @knife.config[:environment] = 'production' - @rest_mock.should_receive(:get_rest). + expect(@rest_mock).to receive(:get_rest). with('/environments/production/cookbooks?num_versions=1'). and_return(@cookbook_data) @knife.run @@ -56,11 +56,11 @@ describe Chef::Knife::CookbookList do describe 'with -w or --with-uri' do it 'should display the cookbook uris' do @knife.config[:with_uri] = true - @rest_mock.stub(:get_rest).and_return(@cookbook_data) + allow(@rest_mock).to receive(:get_rest).and_return(@cookbook_data) @knife.run @cookbook_names.each do |item| pattern = /#{Regexp.escape(@cookbook_data[item]['versions'].first['url'])}/ - @stdout.string.should match pattern + expect(@stdout.string).to match pattern end end end @@ -75,11 +75,11 @@ describe Chef::Knife::CookbookList do it 'should display all versions of the cookbooks' do @knife.config[:all_versions] = true - @rest_mock.should_receive(:get_rest).with('/cookbooks?num_versions=all'). + expect(@rest_mock).to receive(:get_rest).with('/cookbooks?num_versions=all'). and_return(@cookbook_data) @knife.run @cookbook_names.each do |item| - @stdout.string.should match /#{item}\s+1\.0\.1\s+1\.0\.0/ + expect(@stdout.string).to match /#{item}\s+1\.0\.1\s+1\.0\.0/ end end end diff --git a/spec/unit/knife/cookbook_metadata_from_file_spec.rb b/spec/unit/knife/cookbook_metadata_from_file_spec.rb index 68ab6740ab..456e378ca2 100644 --- a/spec/unit/knife/cookbook_metadata_from_file_spec.rb +++ b/spec/unit/knife/cookbook_metadata_from_file_spec.rb @@ -27,10 +27,10 @@ describe Chef::Knife::CookbookMetadataFromFile do @tgt = File.expand_path(File.join(CHEF_SPEC_DATA, "metadata", "quick_start", "metadata.json")) @knife = Chef::Knife::CookbookMetadataFromFile.new @knife.name_args = [ @src ] - @knife.stub(:to_json_pretty).and_return(true) + allow(@knife).to receive(:to_json_pretty).and_return(true) @md = Chef::Cookbook::Metadata.new - Chef::Cookbook::Metadata.stub(:new).and_return(@md) - $stdout.stub(:write) + allow(Chef::Cookbook::Metadata).to receive(:new).and_return(@md) + allow($stdout).to receive(:write) end after do @@ -41,23 +41,23 @@ describe Chef::Knife::CookbookMetadataFromFile do describe "run" do it "should determine cookbook name from path" do - @md.should_receive(:name).with() - @md.should_receive(:name).with("quick_start") + expect(@md).to receive(:name).with(no_args) + expect(@md).to receive(:name).with("quick_start") @knife.run end it "should load the metadata source" do - @md.should_receive(:from_file).with(@src) + expect(@md).to receive(:from_file).with(@src) @knife.run end it "should write out the metadata to the correct location" do - File.should_receive(:open).with(@tgt, "w") + expect(File).to receive(:open).with(@tgt, "w") @knife.run end it "should generate json from the metadata" do - Chef::JSONCompat.should_receive(:to_json_pretty).with(@md) + expect(Chef::JSONCompat).to receive(:to_json_pretty).with(@md) @knife.run end diff --git a/spec/unit/knife/cookbook_metadata_spec.rb b/spec/unit/knife/cookbook_metadata_spec.rb index 1d6568739c..861d85f1f7 100644 --- a/spec/unit/knife/cookbook_metadata_spec.rb +++ b/spec/unit/knife/cookbook_metadata_spec.rb @@ -26,25 +26,25 @@ describe Chef::Knife::CookbookMetadata do @json_data = '{ "version": "1.0.0" }' @stdout = StringIO.new @stderr = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) - @knife.ui.stub(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) end describe 'run' do it 'should print an error and exit if a cookbook name was not provided' do @knife.name_args = [] - @knife.ui.should_receive(:error).with(/you must specify the cookbook.+use the --all/i) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:error).with(/you must specify the cookbook.+use the --all/i) + expect { @knife.run }.to raise_error(SystemExit) end it 'should print an error and exit if an empty cookbook name was provided' do @knife.name_args = [''] - @knife.ui.should_receive(:error).with(/you must specify the cookbook.+use the --all/i) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:error).with(/you must specify the cookbook.+use the --all/i) + expect { @knife.run }.to raise_error(SystemExit) end it 'should generate the metadata for the cookbook' do - @knife.should_receive(:generate_metadata).with('foobar') + expect(@knife).to receive(:generate_metadata).with('foobar') @knife.run end @@ -59,21 +59,21 @@ describe Chef::Knife::CookbookMetadata do "foo" => @foo, "bar" => @bar } - @cookbook_loader.should_receive(:load_cookbooks).and_return(@cookbook_loader) - @knife.should_receive(:generate_metadata).with('foo') - @knife.should_receive(:generate_metadata).with('bar') + expect(@cookbook_loader).to receive(:load_cookbooks).and_return(@cookbook_loader) + expect(@knife).to receive(:generate_metadata).with('foo') + expect(@knife).to receive(:generate_metadata).with('bar') end it 'should generate the metadata for each cookbook' do Chef::Config[:cookbook_path] = @cookbook_dir - Chef::CookbookLoader.should_receive(:new).with(@cookbook_dir).and_return(@cookbook_loader) + expect(Chef::CookbookLoader).to receive(:new).with(@cookbook_dir).and_return(@cookbook_loader) @knife.run end describe 'and with -o or --cookbook-path' do it 'should look in the provided path and generate cookbook metadata' do @knife.config[:cookbook_path] = '/opt/chef/cookbooks' - Chef::CookbookLoader.should_receive(:new).with('/opt/chef/cookbooks').and_return(@cookbook_loader) + expect(Chef::CookbookLoader).to receive(:new).with('/opt/chef/cookbooks').and_return(@cookbook_loader) @knife.run end end @@ -84,21 +84,21 @@ describe Chef::Knife::CookbookMetadata do describe 'generate_metadata' do before(:each) do @knife.config[:cookbook_path] = @cookbook_dir - File.stub(:expand_path).with("#{@cookbook_dir}/foobar/metadata.rb"). + allow(File).to receive(:expand_path).with("#{@cookbook_dir}/foobar/metadata.rb"). and_return("#{@cookbook_dir}/foobar/metadata.rb") end it 'should generate the metadata from metadata.rb if it exists' do - File.should_receive(:exists?).with("#{@cookbook_dir}/foobar/metadata.rb"). + expect(File).to receive(:exists?).with("#{@cookbook_dir}/foobar/metadata.rb"). and_return(true) - @knife.should_receive(:generate_metadata_from_file).with('foobar', "#{@cookbook_dir}/foobar/metadata.rb") + expect(@knife).to receive(:generate_metadata_from_file).with('foobar', "#{@cookbook_dir}/foobar/metadata.rb") @knife.run end it 'should validate the metadata json if metadata.rb does not exist' do - File.should_receive(:exists?).with("#{@cookbook_dir}/foobar/metadata.rb"). + expect(File).to receive(:exists?).with("#{@cookbook_dir}/foobar/metadata.rb"). and_return(false) - @knife.should_receive(:validate_metadata_json).with(@cookbook_dir, 'foobar') + expect(@knife).to receive(:validate_metadata_json).with(@cookbook_dir, 'foobar') @knife.run end end @@ -110,16 +110,16 @@ describe Chef::Knife::CookbookMetadata do end it 'should generate the metatdata json from metatdata.rb' do - Chef::Cookbook::Metadata.stub(:new).and_return(@metadata_mock) - @metadata_mock.should_receive(:name).with('foobar') - @metadata_mock.should_receive(:from_file).with("#{@cookbook_dir}/foobar/metadata.rb") - File.should_receive(:open).with("#{@cookbook_dir}/foobar/metadata.json", 'w'). + allow(Chef::Cookbook::Metadata).to receive(:new).and_return(@metadata_mock) + expect(@metadata_mock).to receive(:name).with('foobar') + expect(@metadata_mock).to receive(:from_file).with("#{@cookbook_dir}/foobar/metadata.rb") + expect(File).to receive(:open).with("#{@cookbook_dir}/foobar/metadata.json", 'w'). and_yield(@json_file_mock) - @json_file_mock.should_receive(:write).with(@json_data) - Chef::JSONCompat.should_receive(:to_json_pretty).with(@metadata_mock). + expect(@json_file_mock).to receive(:write).with(@json_data) + expect(Chef::JSONCompat).to receive(:to_json_pretty).with(@metadata_mock). and_return(@json_data) @knife.generate_metadata_from_file('foobar', "#{@cookbook_dir}/foobar/metadata.rb") - @stderr.string.should match /generating metadata for foobar from #{@cookbook_dir}\/foobar\/metadata\.rb/im + expect(@stderr.string).to match /generating metadata for foobar from #{@cookbook_dir}\/foobar\/metadata\.rb/im end { Chef::Exceptions::ObsoleteDependencySyntax => 'obsolote dependency', @@ -127,32 +127,32 @@ describe Chef::Knife::CookbookMetadata do }.each_pair do |klass, description| it "should print an error and exit when an #{description} syntax exception is encountered" do exception = klass.new("#{description} blah") - Chef::Cookbook::Metadata.stub(:new).and_raise(exception) - lambda { + allow(Chef::Cookbook::Metadata).to receive(:new).and_raise(exception) + expect { @knife.generate_metadata_from_file('foobar', "#{@cookbook_dir}/foobar/metadata.rb") - }.should raise_error(SystemExit) - @stderr.string.should match /error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im - @stderr.string.should match /in #{@cookbook_dir}\/foobar\/metadata\.rb/im - @stderr.string.should match /#{description} blah/im + }.to raise_error(SystemExit) + expect(@stderr.string).to match /error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im + expect(@stderr.string).to match /in #{@cookbook_dir}\/foobar\/metadata\.rb/im + expect(@stderr.string).to match /#{description} blah/im end end end describe 'validate_metadata_json' do it 'should validate the metadata json' do - File.should_receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json"). + expect(File).to receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json"). and_return(true) - IO.should_receive(:read).with("#{@cookbook_dir}/foobar/metadata.json"). + expect(IO).to receive(:read).with("#{@cookbook_dir}/foobar/metadata.json"). and_return(@json_data) - Chef::Cookbook::Metadata.should_receive(:validate_json).with(@json_data) + expect(Chef::Cookbook::Metadata).to receive(:validate_json).with(@json_data) @knife.validate_metadata_json(@cookbook_dir, 'foobar') end it 'should not try to validate the metadata json if the file does not exist' do - File.should_receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json"). + expect(File).to receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json"). and_return(false) - IO.should_not_receive(:read) - Chef::Cookbook::Metadata.should_not_receive(:validate_json) + expect(IO).not_to receive(:read) + expect(Chef::Cookbook::Metadata).not_to receive(:validate_json) @knife.validate_metadata_json(@cookbook_dir, 'foobar') end @@ -160,18 +160,18 @@ describe Chef::Knife::CookbookMetadata do Chef::Exceptions::InvalidVersionConstraint => 'invalid version constraint' }.each_pair do |klass, description| it "should print an error and exit when an #{description} syntax exception is encountered" do - File.should_receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json"). + expect(File).to receive(:exist?).with("#{@cookbook_dir}/foobar/metadata.json"). and_return(true) - IO.should_receive(:read).with("#{@cookbook_dir}/foobar/metadata.json"). + expect(IO).to receive(:read).with("#{@cookbook_dir}/foobar/metadata.json"). and_return(@json_data) exception = klass.new("#{description} blah") - Chef::Cookbook::Metadata.stub(:validate_json).and_raise(exception) - lambda { + allow(Chef::Cookbook::Metadata).to receive(:validate_json).and_raise(exception) + expect { @knife.validate_metadata_json(@cookbook_dir, 'foobar') - }.should raise_error(SystemExit) - @stderr.string.should match /error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im - @stderr.string.should match /in #{@cookbook_dir}\/foobar\/metadata\.json/im - @stderr.string.should match /#{description} blah/im + }.to raise_error(SystemExit) + expect(@stderr.string).to match /error: the cookbook 'foobar' contains invalid or obsolete metadata syntax/im + expect(@stderr.string).to match /in #{@cookbook_dir}\/foobar\/metadata\.json/im + expect(@stderr.string).to match /#{description} blah/im end end end diff --git a/spec/unit/knife/cookbook_show_spec.rb b/spec/unit/knife/cookbook_show_spec.rb index b862c3154c..bf480e3678 100644 --- a/spec/unit/knife/cookbook_show_spec.rb +++ b/spec/unit/knife/cookbook_show_spec.rb @@ -26,18 +26,18 @@ describe Chef::Knife::CookbookShow do @knife.config = { } @knife.name_args = [ "cookbook_name" ] @rest = double(Chef::REST) - @knife.stub(:rest).and_return(@rest) - @knife.stub(:pretty_print).and_return(true) - @knife.stub(:output).and_return(true) + allow(@knife).to receive(:rest).and_return(@rest) + allow(@knife).to receive(:pretty_print).and_return(true) + allow(@knife).to receive(:output).and_return(true) end describe "run" do describe "with 0 arguments: help" do it 'should should print usage and exit when given no arguments' do @knife.name_args = [] - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end end @@ -56,15 +56,15 @@ describe Chef::Knife::CookbookShow do end it "should show the raw cookbook data" do - @rest.should_receive(:get_rest).with("cookbooks/cookbook_name").and_return(@response) - @knife.should_receive(:format_cookbook_list_for_display).with(@response) + expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name").and_return(@response) + expect(@knife).to receive(:format_cookbook_list_for_display).with(@response) @knife.run end it "should respect the user-supplied environment" do @knife.config[:environment] = "foo" - @rest.should_receive(:get_rest).with("environments/foo/cookbooks/cookbook_name").and_return(@response) - @knife.should_receive(:format_cookbook_list_for_display).with(@response) + expect(@rest).to receive(:get_rest).with("environments/foo/cookbooks/cookbook_name").and_return(@response) + expect(@knife).to receive(:format_cookbook_list_for_display).with(@response) @knife.run end end @@ -76,8 +76,8 @@ describe Chef::Knife::CookbookShow do end it "should show the specific part of a cookbook" do - @rest.should_receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@response) - @knife.should_receive(:output).with(@response) + expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@response) + expect(@knife).to receive(:output).with(@response) @knife.run end end @@ -101,8 +101,8 @@ describe Chef::Knife::CookbookShow do end it "should print the json of the part" do - @rest.should_receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) - @knife.should_receive(:output).with(@cookbook_response.manifest["recipes"]) + expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) + expect(@knife).to receive(:output).with(@cookbook_response.manifest["recipes"]) @knife.run end end @@ -125,9 +125,9 @@ describe Chef::Knife::CookbookShow do end it "should print the raw result of the request (likely a file!)" do - @rest.should_receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) - @rest.should_receive(:get_rest).with("http://example.org/files/default.rb", true).and_return(StringIO.new(@response)) - @knife.should_receive(:pretty_print).with(@response) + expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) + expect(@rest).to receive(:get_rest).with("http://example.org/files/default.rb", true).and_return(StringIO.new(@response)) + expect(@knife).to receive(:pretty_print).with(@response) @knife.run end end @@ -177,9 +177,9 @@ describe Chef::Knife::CookbookShow do @knife.config[:platform] = "example_platform" @knife.config[:platform_version] = "1.0" @knife.config[:fqdn] = "examplehost.example.org" - @rest.should_receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) - @rest.should_receive(:get_rest).with("http://example.org/files/1111", true).and_return(StringIO.new(@response)) - @knife.should_receive(:pretty_print).with(@response) + expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) + expect(@rest).to receive(:get_rest).with("http://example.org/files/1111", true).and_return(StringIO.new(@response)) + expect(@knife).to receive(:pretty_print).with(@response) @knife.run end end @@ -189,9 +189,9 @@ describe Chef::Knife::CookbookShow do @knife.config[:platform] = "ubuntu" @knife.config[:platform_version] = "1.0" @knife.config[:fqdn] = "differenthost.example.org" - @rest.should_receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) - @rest.should_receive(:get_rest).with("http://example.org/files/3333", true).and_return(StringIO.new(@response)) - @knife.should_receive(:pretty_print).with(@response) + expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) + expect(@rest).to receive(:get_rest).with("http://example.org/files/3333", true).and_return(StringIO.new(@response)) + expect(@knife).to receive(:pretty_print).with(@response) @knife.run end end @@ -201,18 +201,18 @@ describe Chef::Knife::CookbookShow do @knife.config[:platform] = "ubuntu" @knife.config[:platform_version] = "9.10" @knife.config[:fqdn] = "differenthost.example.org" - @rest.should_receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) - @rest.should_receive(:get_rest).with("http://example.org/files/2222", true).and_return(StringIO.new(@response)) - @knife.should_receive(:pretty_print).with(@response) + expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) + expect(@rest).to receive(:get_rest).with("http://example.org/files/2222", true).and_return(StringIO.new(@response)) + expect(@knife).to receive(:pretty_print).with(@response) @knife.run end end describe "with none of the arguments, it should use the default" do it "should pass them all" do - @rest.should_receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) - @rest.should_receive(:get_rest).with("http://example.org/files/4444", true).and_return(StringIO.new(@response)) - @knife.should_receive(:pretty_print).with(@response) + expect(@rest).to receive(:get_rest).with("cookbooks/cookbook_name/0.1.0").and_return(@cookbook_response) + expect(@rest).to receive(:get_rest).with("http://example.org/files/4444", true).and_return(StringIO.new(@response)) + expect(@knife).to receive(:pretty_print).with(@response) @knife.run end end diff --git a/spec/unit/knife/cookbook_site_download_spec.rb b/spec/unit/knife/cookbook_site_download_spec.rb index 76ce6508d7..6676fb34a1 100644 --- a/spec/unit/knife/cookbook_site_download_spec.rb +++ b/spec/unit/knife/cookbook_site_download_spec.rb @@ -33,9 +33,9 @@ describe Chef::Knife::CookbookSiteDownload do 'latest_version' => "#{@cookbook_api_url}/apache2/versions/#{@version_us}", 'replacement' => 'other_apache2' } - @knife.ui.stub(:stderr).and_return(@stderr) - @knife.stub(:noauth_rest).and_return(@noauth_rest) - @noauth_rest.should_receive(:get_rest). + allow(@knife.ui).to receive(:stderr).and_return(@stderr) + allow(@knife).to receive(:noauth_rest).and_return(@noauth_rest) + expect(@noauth_rest).to receive(:get_rest). with("#{@cookbook_api_url}/apache2"). and_return(@current_data) end @@ -46,9 +46,9 @@ describe Chef::Knife::CookbookSiteDownload do end it 'should warn with info about the replacement' do - @knife.ui.should_receive(:warn). + expect(@knife.ui).to receive(:warn). with(/.+deprecated.+replaced by other_apache2.+/i) - @knife.ui.should_receive(:warn). + expect(@knife.ui).to receive(:warn). with(/use --force.+download.+/i) @knife.run end @@ -61,15 +61,15 @@ describe Chef::Knife::CookbookSiteDownload do @temp_file = double( :path => "/tmp/apache2_#{@version_us}.tgz" ) @file = File.join(Dir.pwd, "apache2-#{@version}.tar.gz") - @noauth_rest.should_receive(:sign_on_redirect=).with(false) + expect(@noauth_rest).to receive(:sign_on_redirect=).with(false) end context 'downloading the latest version' do before do - @noauth_rest.should_receive(:get_rest). + expect(@noauth_rest).to receive(:get_rest). with(@current_data['latest_version']). and_return(@cookbook_data) - @noauth_rest.should_receive(:get_rest). + expect(@noauth_rest).to receive(:get_rest). with(@cookbook_data['file'], true). and_return(@temp_file) end @@ -81,40 +81,40 @@ describe Chef::Knife::CookbookSiteDownload do end it 'should download the latest version' do - @knife.ui.should_receive(:warn). + expect(@knife.ui).to receive(:warn). with(/.+deprecated.+replaced by other_apache2.+/i) - FileUtils.should_receive(:cp).with(@temp_file.path, @file) + expect(FileUtils).to receive(:cp).with(@temp_file.path, @file) @knife.run - @stderr.string.should match /downloading apache2.+version.+#{Regexp.escape(@version)}/i - @stderr.string.should match /cookbook save.+#{Regexp.escape(@file)}/i + expect(@stderr.string).to match /downloading apache2.+version.+#{Regexp.escape(@version)}/i + expect(@stderr.string).to match /cookbook save.+#{Regexp.escape(@file)}/i end end it 'should download the latest version' do - FileUtils.should_receive(:cp).with(@temp_file.path, @file) + expect(FileUtils).to receive(:cp).with(@temp_file.path, @file) @knife.run - @stderr.string.should match /downloading apache2.+version.+#{Regexp.escape(@version)}/i - @stderr.string.should match /cookbook save.+#{Regexp.escape(@file)}/i + expect(@stderr.string).to match /downloading apache2.+version.+#{Regexp.escape(@version)}/i + expect(@stderr.string).to match /cookbook save.+#{Regexp.escape(@file)}/i end context 'with -f or --file' do before do @file = '/opt/chef/cookbooks/apache2.tar.gz' @knife.config[:file] = @file - FileUtils.should_receive(:cp).with(@temp_file.path, @file) + expect(FileUtils).to receive(:cp).with(@temp_file.path, @file) end it 'should download the cookbook to the desired file' do @knife.run - @stderr.string.should match /downloading apache2.+version.+#{Regexp.escape(@version)}/i - @stderr.string.should match /cookbook save.+#{Regexp.escape(@file)}/i + expect(@stderr.string).to match /downloading apache2.+version.+#{Regexp.escape(@version)}/i + expect(@stderr.string).to match /cookbook save.+#{Regexp.escape(@file)}/i end end it 'should provide an accessor to the version' do - FileUtils.stub(:cp).and_return(true) - @knife.version.should == @version + allow(FileUtils).to receive(:cp).and_return(true) + expect(@knife.version).to eq(@version) @knife.run end end @@ -131,16 +131,16 @@ describe Chef::Knife::CookbookSiteDownload do end it 'should download the desired version' do - @noauth_rest.should_receive(:get_rest). + expect(@noauth_rest).to receive(:get_rest). with("#{@cookbook_api_url}/apache2/versions/#{@version_us}"). and_return(@cookbook_data) - @noauth_rest.should_receive(:get_rest). + expect(@noauth_rest).to receive(:get_rest). with(@cookbook_data['file'], true). and_return(@temp_file) - FileUtils.should_receive(:cp).with(@temp_file.path, @file) + expect(FileUtils).to receive(:cp).with(@temp_file.path, @file) @knife.run - @stderr.string.should match /downloading apache2.+version.+#{Regexp.escape(@version)}/i - @stderr.string.should match /cookbook save.+#{Regexp.escape(@file)}/i + expect(@stderr.string).to match /downloading apache2.+version.+#{Regexp.escape(@version)}/i + expect(@stderr.string).to match /cookbook save.+#{Regexp.escape(@file)}/i end end diff --git a/spec/unit/knife/cookbook_site_install_spec.rb b/spec/unit/knife/cookbook_site_install_spec.rb index ff87a81b49..c4bd8f67d2 100644 --- a/spec/unit/knife/cookbook_site_install_spec.rb +++ b/spec/unit/knife/cookbook_site_install_spec.rb @@ -23,7 +23,7 @@ describe Chef::Knife::CookbookSiteInstall do require 'chef/knife/core/cookbook_scm_repo' @stdout = StringIO.new @knife = Chef::Knife::CookbookSiteInstall.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) @knife.config = {} if Chef::Platform.windows? @install_path = 'C:/tmp/chef' @@ -34,18 +34,18 @@ describe Chef::Knife::CookbookSiteInstall do @stdout = StringIO.new @stderr = StringIO.new - @knife.stub(:stderr).and_return(@stdout) - @knife.stub(:stdout).and_return(@stdout) + allow(@knife).to receive(:stderr).and_return(@stdout) + allow(@knife).to receive(:stdout).and_return(@stdout) #Assume all external commands would have succeed. :( - File.stub(:unlink) - File.stub(:rmtree) - @knife.stub(:shell_out!).and_return(true) + allow(File).to receive(:unlink) + allow(File).to receive(:rmtree) + allow(@knife).to receive(:shell_out!).and_return(true) #CookbookSiteDownload Stup @downloader = {} - @knife.stub(:download_cookbook_to).and_return(@downloader) - @downloader.stub(:version).and_return do + allow(@knife).to receive(:download_cookbook_to).and_return(@downloader) + allow(@downloader).to receive(:version) do if @knife.name_args.size == 2 @knife.name_args[1] else @@ -57,49 +57,49 @@ describe Chef::Knife::CookbookSiteInstall do @repo = double(:sanity_check => true, :reset_to_default_state => true, :prepare_to_import => true, :finalize_updates_to => true, :merge_updates_from => true) - Chef::Knife::CookbookSCMRepo.stub(:new).and_return(@repo) + allow(Chef::Knife::CookbookSCMRepo).to receive(:new).and_return(@repo) end describe "run" do it "should return an error if a cookbook name is not provided" do @knife.name_args = [] - @knife.ui.should_receive(:error).with("Please specify a cookbook to download and install.") - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:error).with("Please specify a cookbook to download and install.") + expect { @knife.run }.to raise_error(SystemExit) end it "should return an error if more than two arguments are given" do @knife.name_args = ["foo", "bar", "baz"] - @knife.ui.should_receive(:error).with("Installing multiple cookbooks at once is not supported.") - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.") + expect { @knife.run }.to raise_error(SystemExit) end it "should return an error if the second argument is not a version" do @knife.name_args = ["getting-started", "1pass"] - @knife.ui.should_receive(:error).with("Installing multiple cookbooks at once is not supported.") - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.") + expect { @knife.run }.to raise_error(SystemExit) end it "should return an error if the second argument is a four-digit version" do @knife.name_args = ["getting-started", "0.0.0.1"] - @knife.ui.should_receive(:error).with("Installing multiple cookbooks at once is not supported.") - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.") + expect { @knife.run }.to raise_error(SystemExit) end it "should return an error if the second argument is a one-digit version" do @knife.name_args = ["getting-started", "1"] - @knife.ui.should_receive(:error).with("Installing multiple cookbooks at once is not supported.") - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:error).with("Installing multiple cookbooks at once is not supported.") + expect { @knife.run }.to raise_error(SystemExit) end it "should install the specified version if second argument is a three-digit version" do @knife.name_args = ["getting-started", "0.1.0"] @knife.config[:no_deps] = true upstream_file = File.join(@install_path, "getting-started.tar.gz") - @knife.should_receive(:download_cookbook_to).with(upstream_file) - @knife.should_receive(:extract_cookbook).with(upstream_file, "0.1.0") - @knife.should_receive(:clear_existing_files).with(File.join(@install_path, "getting-started")) - @repo.should_receive(:merge_updates_from).with("getting-started", "0.1.0") + expect(@knife).to receive(:download_cookbook_to).with(upstream_file) + expect(@knife).to receive(:extract_cookbook).with(upstream_file, "0.1.0") + expect(@knife).to receive(:clear_existing_files).with(File.join(@install_path, "getting-started")) + expect(@repo).to receive(:merge_updates_from).with("getting-started", "0.1.0") @knife.run end @@ -107,10 +107,10 @@ describe Chef::Knife::CookbookSiteInstall do @knife.name_args = ["getting-started", "0.1"] @knife.config[:no_deps] = true upstream_file = File.join(@install_path, "getting-started.tar.gz") - @knife.should_receive(:download_cookbook_to).with(upstream_file) - @knife.should_receive(:extract_cookbook).with(upstream_file, "0.1") - @knife.should_receive(:clear_existing_files).with(File.join(@install_path, "getting-started")) - @repo.should_receive(:merge_updates_from).with("getting-started", "0.1") + expect(@knife).to receive(:download_cookbook_to).with(upstream_file) + expect(@knife).to receive(:extract_cookbook).with(upstream_file, "0.1") + expect(@knife).to receive(:clear_existing_files).with(File.join(@install_path, "getting-started")) + expect(@repo).to receive(:merge_updates_from).with("getting-started", "0.1") @knife.run end @@ -118,10 +118,10 @@ describe Chef::Knife::CookbookSiteInstall do @knife.name_args = ["getting-started"] @knife.config[:no_deps] = true upstream_file = File.join(@install_path, "getting-started.tar.gz") - @knife.should_receive(:download_cookbook_to).with(upstream_file) - @knife.should_receive(:extract_cookbook).with(upstream_file, "0.3.0") - @knife.should_receive(:clear_existing_files).with(File.join(@install_path, "getting-started")) - @repo.should_receive(:merge_updates_from).with("getting-started", "0.3.0") + expect(@knife).to receive(:download_cookbook_to).with(upstream_file) + expect(@knife).to receive(:extract_cookbook).with(upstream_file, "0.3.0") + expect(@knife).to receive(:clear_existing_files).with(File.join(@install_path, "getting-started")) + expect(@repo).to receive(:merge_updates_from).with("getting-started", "0.3.0") @knife.run end @@ -130,8 +130,8 @@ describe Chef::Knife::CookbookSiteInstall do @knife.config[:use_current_branch] = true @knife.config[:no_deps] = true upstream_file = File.join(@install_path, "getting-started.tar.gz") - @repo.should_not_receive(:prepare_to_import) - @repo.should_not_receive(:reset_to_default_state) + expect(@repo).not_to receive(:prepare_to_import) + expect(@repo).not_to receive(:reset_to_default_state) @knife.run end @@ -140,11 +140,11 @@ describe Chef::Knife::CookbookSiteInstall do @knife.config[:no_deps] = true @knife.name_args = ["getting-started"] upstream_file = File.join(@install_path, "getting-started.tar.gz") - @knife.should_receive(:download_cookbook_to).with(upstream_file) - @knife.should_receive(:extract_cookbook).with(upstream_file, "0.3.0") - @knife.should_receive(:clear_existing_files).with(File.join(@install_path, "getting-started")) - @repo.should_receive(:merge_updates_from).with("getting-started", "0.3.0") - lambda { @knife.run }.should_not raise_error + expect(@knife).to receive(:download_cookbook_to).with(upstream_file) + expect(@knife).to receive(:extract_cookbook).with(upstream_file, "0.3.0") + expect(@knife).to receive(:clear_existing_files).with(File.join(@install_path, "getting-started")) + expect(@repo).to receive(:merge_updates_from).with("getting-started", "0.3.0") + expect { @knife.run }.not_to raise_error end end end diff --git a/spec/unit/knife/cookbook_site_share_spec.rb b/spec/unit/knife/cookbook_site_share_spec.rb index b85db98d53..0f97261ad4 100644 --- a/spec/unit/knife/cookbook_site_share_spec.rb +++ b/spec/unit/knife/cookbook_site_share_spec.rb @@ -32,27 +32,27 @@ describe Chef::Knife::CookbookSiteShare do @cookbook = Chef::CookbookVersion.new('cookbook_name') @cookbook_loader = double('Chef::CookbookLoader') - @cookbook_loader.stub(:cookbook_exists?).and_return(true) - @cookbook_loader.stub(:[]).and_return(@cookbook) - Chef::CookbookLoader.stub(:new).and_return(@cookbook_loader) + allow(@cookbook_loader).to receive(:cookbook_exists?).and_return(true) + allow(@cookbook_loader).to receive(:[]).and_return(@cookbook) + allow(Chef::CookbookLoader).to receive(:new).and_return(@cookbook_loader) @noauth_rest = double(Chef::REST) - @knife.stub(:noauth_rest).and_return(@noauth_rest) + allow(@knife).to receive(:noauth_rest).and_return(@noauth_rest) @cookbook_uploader = Chef::CookbookUploader.new('herpderp', :rest => "norest") - Chef::CookbookUploader.stub(:new).and_return(@cookbook_uploader) - @cookbook_uploader.stub(:validate_cookbooks).and_return(true) - Chef::CookbookSiteStreamingUploader.stub(:create_build_dir).and_return(Dir.mktmpdir) + allow(Chef::CookbookUploader).to receive(:new).and_return(@cookbook_uploader) + allow(@cookbook_uploader).to receive(:validate_cookbooks).and_return(true) + allow(Chef::CookbookSiteStreamingUploader).to receive(:create_build_dir).and_return(Dir.mktmpdir) - @knife.stub(:shell_out!).and_return(true) + allow(@knife).to receive(:shell_out!).and_return(true) @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe 'run' do before(:each) do - @knife.stub(:do_upload).and_return(true) + allow(@knife).to receive(:do_upload).and_return(true) @category_response = { "name" => "cookbook_name", "category" => "Testing Category" @@ -66,72 +66,72 @@ describe Chef::Knife::CookbookSiteShare do end it 'should set true to config[:dry_run] as default' do - @knife.config[:dry_run].should be_false + expect(@knife.config[:dry_run]).to be_falsey end it 'should should print usage and exit when given no arguments' do @knife.name_args = [] - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end it 'should not fail when given only 1 argument and can determine category' do @knife.name_args = ['cookbook_name'] - @noauth_rest.should_receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name").and_return(@category_response) - @knife.should_receive(:do_upload) + expect(@noauth_rest).to receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name").and_return(@category_response) + expect(@knife).to receive(:do_upload) @knife.run end it 'should print error and exit when given only 1 argument and cannot determine category' do @knife.name_args = ['cookbook_name'] - @noauth_rest.should_receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name").and_return(@bad_category_response) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@noauth_rest).to receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name").and_return(@bad_category_response) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end it 'should print error and exit when given only 1 argument and Chef::REST throws an exception' do @knife.name_args = ['cookbook_name'] - @noauth_rest.should_receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name") { raise Errno::ECONNREFUSED, "Connection refused" } - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@noauth_rest).to receive(:get_rest).with("http://cookbooks.opscode.com/api/v1/cookbooks/cookbook_name") { raise Errno::ECONNREFUSED, "Connection refused" } + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end it 'should check if the cookbook exists' do - @cookbook_loader.should_receive(:cookbook_exists?) + expect(@cookbook_loader).to receive(:cookbook_exists?) @knife.run end it "should exit and log to error if the cookbook doesn't exist" do - @cookbook_loader.stub(:cookbook_exists?).and_return(false) - @knife.ui.should_receive(:error) - lambda { @knife.run }.should raise_error(SystemExit) + allow(@cookbook_loader).to receive(:cookbook_exists?).and_return(false) + expect(@knife.ui).to receive(:error) + expect { @knife.run }.to raise_error(SystemExit) end it 'should make a tarball of the cookbook' do - @knife.should_receive(:shell_out!) do |args| - args.to_s.should match(/tar -czf/) + expect(@knife).to receive(:shell_out!) do |args| + expect(args.to_s).to match(/tar -czf/) end @knife.run end it 'should exit and log to error when the tarball creation fails' do - @knife.stub(:shell_out!).and_raise(Chef::Exceptions::Exec) - @knife.ui.should_receive(:error) - lambda { @knife.run }.should raise_error(SystemExit) + allow(@knife).to receive(:shell_out!).and_raise(Chef::Exceptions::Exec) + expect(@knife.ui).to receive(:error) + expect { @knife.run }.to raise_error(SystemExit) end it 'should upload the cookbook and clean up the tarball' do - @knife.should_receive(:do_upload) - FileUtils.should_receive(:rm_rf) + expect(@knife).to receive(:do_upload) + expect(FileUtils).to receive(:rm_rf) @knife.run end context "when the --dry-run flag is specified" do before do - Chef::CookbookSiteStreamingUploader.stub(:create_build_dir).and_return("/var/tmp/dummy") + allow(Chef::CookbookSiteStreamingUploader).to receive(:create_build_dir).and_return("/var/tmp/dummy") @knife.config = { :dry_run => true } - @knife.stub_chain(:shell_out!, :stdout).and_return('file') + allow(@knife).to receive_message_chain(:shell_out!, :stdout).and_return('file') end it "should list files in the tarball" do @@ -152,46 +152,46 @@ describe Chef::Knife::CookbookSiteShare do before(:each) do @upload_response = double('Net::HTTPResponse') - Chef::CookbookSiteStreamingUploader.stub(:post).and_return(@upload_response) + allow(Chef::CookbookSiteStreamingUploader).to receive(:post).and_return(@upload_response) @stdout = StringIO.new @stderr = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) - @knife.ui.stub(:stderr).and_return(@stderr) - File.stub(:open).and_return(true) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) + allow(File).to receive(:open).and_return(true) end it 'should post the cookbook to "https://supermarket.getchef.com"' do response_text = Chef::JSONCompat.to_json({:uri => 'https://supermarket.getchef.com/cookbooks/cookbook_name'}) - @upload_response.stub(:body).and_return(response_text) - @upload_response.stub(:code).and_return(201) - Chef::CookbookSiteStreamingUploader.should_receive(:post).with(/supermarket\.getchef\.com/, anything(), anything(), anything()) + allow(@upload_response).to receive(:body).and_return(response_text) + allow(@upload_response).to receive(:code).and_return(201) + expect(Chef::CookbookSiteStreamingUploader).to receive(:post).with(/supermarket\.getchef\.com/, anything(), anything(), anything()) @knife.run end it 'should alert the user when a version already exists' do response_text = Chef::JSONCompat.to_json({:error_messages => ['Version already exists']}) - @upload_response.stub(:body).and_return(response_text) - @upload_response.stub(:code).and_return(409) - lambda { @knife.run }.should raise_error(SystemExit) - @stderr.string.should match(/ERROR(.+)cookbook already exists/) + allow(@upload_response).to receive(:body).and_return(response_text) + allow(@upload_response).to receive(:code).and_return(409) + expect { @knife.run }.to raise_error(SystemExit) + expect(@stderr.string).to match(/ERROR(.+)cookbook already exists/) end it 'should pass any errors on to the user' do response_text = Chef::JSONCompat.to_json({:error_messages => ["You're holding it wrong"]}) - @upload_response.stub(:body).and_return(response_text) - @upload_response.stub(:code).and_return(403) - lambda { @knife.run }.should raise_error(SystemExit) - @stderr.string.should match("ERROR(.*)You're holding it wrong") + allow(@upload_response).to receive(:body).and_return(response_text) + allow(@upload_response).to receive(:code).and_return(403) + expect { @knife.run }.to raise_error(SystemExit) + expect(@stderr.string).to match("ERROR(.*)You're holding it wrong") end it 'should print the body if no errors are exposed on failure' do response_text = Chef::JSONCompat.to_json({:system_error => "Your call was dropped", :reason => "There's a map for that"}) - @upload_response.stub(:body).and_return(response_text) - @upload_response.stub(:code).and_return(500) - @knife.ui.should_receive(:error).with(/#{Regexp.escape(response_text)}/)#.ordered - @knife.ui.should_receive(:error).with(/Unknown error/)#.ordered - lambda { @knife.run }.should raise_error(SystemExit) + allow(@upload_response).to receive(:body).and_return(response_text) + allow(@upload_response).to receive(:code).and_return(500) + expect(@knife.ui).to receive(:error).with(/#{Regexp.escape(response_text)}/)#.ordered + expect(@knife.ui).to receive(:error).with(/Unknown error/)#.ordered + expect { @knife.run }.to raise_error(SystemExit) end end diff --git a/spec/unit/knife/cookbook_site_unshare_spec.rb b/spec/unit/knife/cookbook_site_unshare_spec.rb index 14cda65b43..ec46a8705c 100644 --- a/spec/unit/knife/cookbook_site_unshare_spec.rb +++ b/spec/unit/knife/cookbook_site_unshare_spec.rb @@ -24,13 +24,13 @@ describe Chef::Knife::CookbookSiteUnshare do before(:each) do @knife = Chef::Knife::CookbookSiteUnshare.new @knife.name_args = ['cookbook_name'] - @knife.stub(:confirm).and_return(true) + allow(@knife).to receive(:confirm).and_return(true) @rest = double('Chef::REST') - @rest.stub(:delete_rest).and_return(true) - @knife.stub(:rest).and_return(@rest) + allow(@rest).to receive(:delete_rest).and_return(true) + allow(@knife).to receive(:rest).and_return(@rest) @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe 'run' do @@ -38,37 +38,37 @@ describe Chef::Knife::CookbookSiteUnshare do describe 'with no cookbook argument' do it 'should print the usage and exit' do @knife.name_args = [] - @knife.ui.should_receive(:fatal) - @knife.should_receive(:show_usage) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:fatal) + expect(@knife).to receive(:show_usage) + expect { @knife.run }.to raise_error(SystemExit) end end it 'should confirm you want to unshare the cookbook' do - @knife.should_receive(:confirm) + expect(@knife).to receive(:confirm) @knife.run end it 'should send a delete request to the cookbook site' do - @rest.should_receive(:delete_rest) + expect(@rest).to receive(:delete_rest) @knife.run end it 'should log an error and exit when forbidden' do exception = double('403 "Forbidden"', :code => '403') - @rest.stub(:delete_rest).and_raise(Net::HTTPServerException.new('403 "Forbidden"', exception)) - @knife.ui.should_receive(:error) - lambda { @knife.run }.should raise_error(SystemExit) + allow(@rest).to receive(:delete_rest).and_raise(Net::HTTPServerException.new('403 "Forbidden"', exception)) + expect(@knife.ui).to receive(:error) + expect { @knife.run }.to raise_error(SystemExit) end it 'should re-raise any non-forbidden errors on delete_rest' do exception = double('500 "Application Error"', :code => '500') - @rest.stub(:delete_rest).and_raise(Net::HTTPServerException.new('500 "Application Error"', exception)) - lambda { @knife.run }.should raise_error(Net::HTTPServerException) + allow(@rest).to receive(:delete_rest).and_raise(Net::HTTPServerException.new('500 "Application Error"', exception)) + expect { @knife.run }.to raise_error(Net::HTTPServerException) end it 'should log a success message' do - @knife.ui.should_receive(:info) + expect(@knife.ui).to receive(:info) @knife.run end diff --git a/spec/unit/knife/cookbook_test_spec.rb b/spec/unit/knife/cookbook_test_spec.rb index 0e261c02a4..ce74bcaa5d 100644 --- a/spec/unit/knife/cookbook_test_spec.rb +++ b/spec/unit/knife/cookbook_test_spec.rb @@ -26,55 +26,55 @@ describe Chef::Knife::CookbookTest do Chef::Config[:node_name] = "webmonkey.example.com" @knife = Chef::Knife::CookbookTest.new @knife.config[:cookbook_path] = File.join(CHEF_SPEC_DATA,'cookbooks') - @knife.cookbook_loader.stub(:cookbook_exists?).and_return(true) + allow(@knife.cookbook_loader).to receive(:cookbook_exists?).and_return(true) @cookbooks = [] %w{tats central_market jimmy_johns pho}.each do |cookbook_name| @cookbooks << Chef::CookbookVersion.new(cookbook_name) end @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe "run" do it "should test the cookbook" do - @knife.stub(:test_cookbook).and_return(true) + allow(@knife).to receive(:test_cookbook).and_return(true) @knife.name_args = ["italian"] - @knife.should_receive(:test_cookbook).with("italian") + expect(@knife).to receive(:test_cookbook).with("italian") @knife.run end it "should test multiple cookbooks when provided" do - @knife.stub(:test_cookbook).and_return(true) + allow(@knife).to receive(:test_cookbook).and_return(true) @knife.name_args = ["tats", "jimmy_johns"] - @knife.should_receive(:test_cookbook).with("tats") - @knife.should_receive(:test_cookbook).with("jimmy_johns") - @knife.should_not_receive(:test_cookbook).with("central_market") - @knife.should_not_receive(:test_cookbook).with("pho") + expect(@knife).to receive(:test_cookbook).with("tats") + expect(@knife).to receive(:test_cookbook).with("jimmy_johns") + expect(@knife).not_to receive(:test_cookbook).with("central_market") + expect(@knife).not_to receive(:test_cookbook).with("pho") @knife.run end it "should test both ruby and templates" do @knife.name_args = ["example"] - @knife.config[:cookbook_path].should_not be_empty + expect(@knife.config[:cookbook_path]).not_to be_empty Array(@knife.config[:cookbook_path]).reverse.each do |path| - @knife.should_receive(:test_ruby).with(an_instance_of(Chef::Cookbook::SyntaxCheck)) - @knife.should_receive(:test_templates).with(an_instance_of(Chef::Cookbook::SyntaxCheck)) + expect(@knife).to receive(:test_ruby).with(an_instance_of(Chef::Cookbook::SyntaxCheck)) + expect(@knife).to receive(:test_templates).with(an_instance_of(Chef::Cookbook::SyntaxCheck)) end @knife.run end describe "with -a or --all" do it "should test all of the cookbooks" do - @knife.stub(:test_cookbook).and_return(true) + allow(@knife).to receive(:test_cookbook).and_return(true) @knife.config[:all] = true @loader = {} - @loader.stub(:load_cookbooks).and_return(@loader) + allow(@loader).to receive(:load_cookbooks).and_return(@loader) @cookbooks.each do |cookbook| @loader[cookbook.name] = cookbook end - @knife.stub(:cookbook_loader).and_return(@loader) + allow(@knife).to receive(:cookbook_loader).and_return(@loader) @loader.each do |key, cookbook| - @knife.should_receive(:test_cookbook).with(cookbook.name) + expect(@knife).to receive(:test_cookbook).with(cookbook.name) end @knife.run end diff --git a/spec/unit/knife/cookbook_upload_spec.rb b/spec/unit/knife/cookbook_upload_spec.rb index e5c9a40cf1..5dbd456ad8 100644 --- a/spec/unit/knife/cookbook_upload_spec.rb +++ b/spec/unit/knife/cookbook_upload_spec.rb @@ -31,8 +31,8 @@ describe Chef::Knife::CookbookUpload do let(:cookbook_loader) do cookbook_loader = cookbooks_by_name.dup - cookbook_loader.stub(:merged_cookbooks).and_return([]) - cookbook_loader.stub(:load_cookbooks).and_return(cookbook_loader) + allow(cookbook_loader).to receive(:merged_cookbooks).and_return([]) + allow(cookbook_loader).to receive(:load_cookbooks).and_return(cookbook_loader) cookbook_loader end @@ -45,23 +45,23 @@ describe Chef::Knife::CookbookUpload do let(:knife) do k = Chef::Knife::CookbookUpload.new k.name_args = name_args - k.ui.stub(:stdout).and_return(output) - k.ui.stub(:stderr).and_return(output) + allow(k.ui).to receive(:stdout).and_return(output) + allow(k.ui).to receive(:stderr).and_return(output) k end before(:each) do - Chef::CookbookLoader.stub(:new).and_return(cookbook_loader) + allow(Chef::CookbookLoader).to receive(:new).and_return(cookbook_loader) end describe 'with --concurrency' do it 'should upload cookbooks with predefined concurrency' do - Chef::CookbookVersion.stub(:list_all_versions).and_return({}) + allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({}) knife.config[:concurrency] = 3 test_cookbook = Chef::CookbookVersion.new('test_cookbook', '/tmp/blah') - cookbook_loader.stub(:each).and_yield("test_cookbook", test_cookbook) - cookbook_loader.stub(:cookbook_names).and_return(["test_cookbook"]) - Chef::CookbookUploader.should_receive(:new). + allow(cookbook_loader).to receive(:each).and_yield("test_cookbook", test_cookbook) + allow(cookbook_loader).to receive(:cookbook_names).and_return(["test_cookbook"]) + expect(Chef::CookbookUploader).to receive(:new). with( kind_of(Array), { :force => nil, :concurrency => 3}). and_return(double("Chef::CookbookUploader", :upload_cookbooks=> true)) knife.run @@ -70,26 +70,26 @@ describe Chef::Knife::CookbookUpload do describe 'run' do before(:each) do - Chef::CookbookUploader.stub(:new => cookbook_uploader) - Chef::CookbookVersion.stub(:list_all_versions).and_return({}) + allow(Chef::CookbookUploader).to receive_messages(:new => cookbook_uploader) + allow(Chef::CookbookVersion).to receive(:list_all_versions).and_return({}) end it 'should print usage and exit when a cookbook name is not provided' do knife.name_args = [] - knife.should_receive(:show_usage) - knife.ui.should_receive(:fatal) - lambda { knife.run }.should raise_error(SystemExit) + expect(knife).to receive(:show_usage) + expect(knife.ui).to receive(:fatal) + expect { knife.run }.to raise_error(SystemExit) end describe 'when specifying a cookbook name' do it 'should upload the cookbook' do - knife.should_receive(:upload).once + expect(knife).to receive(:upload).once knife.run end it 'should report on success' do - knife.should_receive(:upload).once - knife.ui.should_receive(:info).with(/Uploaded 1 cookbook/) + expect(knife).to receive(:upload).once + expect(knife.ui).to receive(:info).with(/Uploaded 1 cookbook/) knife.run end end @@ -97,7 +97,7 @@ describe Chef::Knife::CookbookUpload do describe 'when specifying the same cookbook name twice' do it 'should upload the cookbook only once' do knife.name_args = ['test_cookbook', 'test_cookbook'] - knife.should_receive(:upload).once + expect(knife).to receive(:upload).once knife.run end end @@ -105,8 +105,8 @@ describe Chef::Knife::CookbookUpload do context "when uploading a cookbook that uses deprecated overlays" do before do - cookbook_loader.stub(:merged_cookbooks).and_return(['test_cookbook']) - cookbook_loader.stub(:merged_cookbook_paths). + allow(cookbook_loader).to receive(:merged_cookbooks).and_return(['test_cookbook']) + allow(cookbook_loader).to receive(:merged_cookbook_paths). and_return({'test_cookbook' => %w{/path/one/test_cookbook /path/two/test_cookbook}}) end @@ -123,7 +123,7 @@ test_cookbook: /path/one/test_cookbook /path/two/test_cookbook E - output.string.should include(expected_message) + expect(output.string).to include(expected_message) end end @@ -139,17 +139,17 @@ E end it "should read only one cookbook" do - cookbook_loader.should_receive(:[]).once.with('test_cookbook1').and_call_original + expect(cookbook_loader).to receive(:[]).once.with('test_cookbook1').and_call_original knife.run end it "should not read all cookbooks" do - cookbook_loader.should_not_receive(:load_cookbooks) + expect(cookbook_loader).not_to receive(:load_cookbooks) knife.run end it "should upload only one cookbook" do - knife.should_receive(:upload).exactly(1).times + expect(knife).to receive(:upload).exactly(1).times knife.run end end @@ -181,13 +181,13 @@ E it "should upload all dependencies once" do knife.config[:depends] = true - knife.stub(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2", "test_cookbook3"]) - knife.should_receive(:upload).exactly(3).times - lambda do + allow(knife).to receive(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2", "test_cookbook3"]) + expect(knife).to receive(:upload).exactly(3).times + expect do Timeout::timeout(5) do knife.run end - end.should_not raise_error + end.not_to raise_error end end @@ -196,50 +196,50 @@ E before(:each) do cookbook.metadata.depends("dependency") - cookbook_loader.stub(:[]) do |ckbk| + allow(cookbook_loader).to receive(:[]) do |ckbk| { "test_cookbook" => cookbook, "dependency" => cookbook_dependency}[ckbk] end - knife.stub(:cookbook_names).and_return(["cookbook_dependency", "test_cookbook"]) + allow(knife).to receive(:cookbook_names).and_return(["cookbook_dependency", "test_cookbook"]) @stdout, @stderr, @stdin = StringIO.new, StringIO.new, StringIO.new knife.ui = Chef::Knife::UI.new(@stdout, @stderr, @stdin, {}) end it 'should exit and not upload the cookbook' do - cookbook_loader.should_receive(:[]).once.with('test_cookbook') - cookbook_loader.should_not_receive(:load_cookbooks) - cookbook_uploader.should_not_receive(:upload_cookbooks) + expect(cookbook_loader).to receive(:[]).once.with('test_cookbook') + expect(cookbook_loader).not_to receive(:load_cookbooks) + expect(cookbook_uploader).not_to receive(:upload_cookbooks) expect {knife.run}.to raise_error(SystemExit) end it 'should output a message for a single missing dependency' do expect {knife.run}.to raise_error(SystemExit) - @stderr.string.should include('Cookbook test_cookbook depends on cookbooks which are not currently') - @stderr.string.should include('being uploaded and cannot be found on the server.') - @stderr.string.should include("The missing cookbook(s) are: 'dependency' version '>= 0.0.0'") + expect(@stderr.string).to include('Cookbook test_cookbook depends on cookbooks which are not currently') + expect(@stderr.string).to include('being uploaded and cannot be found on the server.') + expect(@stderr.string).to include("The missing cookbook(s) are: 'dependency' version '>= 0.0.0'") end it 'should output a message for a multiple missing dependencies which are concatenated' do cookbook_dependency2 = Chef::CookbookVersion.new('dependency2') cookbook.metadata.depends("dependency2") - cookbook_loader.stub(:[]) do |ckbk| + allow(cookbook_loader).to receive(:[]) do |ckbk| { "test_cookbook" => cookbook, "dependency" => cookbook_dependency, "dependency2" => cookbook_dependency2}[ckbk] end - knife.stub(:cookbook_names).and_return(["dependency", "dependency2", "test_cookbook"]) + allow(knife).to receive(:cookbook_names).and_return(["dependency", "dependency2", "test_cookbook"]) expect {knife.run}.to raise_error(SystemExit) - @stderr.string.should include('Cookbook test_cookbook depends on cookbooks which are not currently') - @stderr.string.should include('being uploaded and cannot be found on the server.') - @stderr.string.should include("The missing cookbook(s) are:") - @stderr.string.should include("'dependency' version '>= 0.0.0'") - @stderr.string.should include("'dependency2' version '>= 0.0.0'") + expect(@stderr.string).to include('Cookbook test_cookbook depends on cookbooks which are not currently') + expect(@stderr.string).to include('being uploaded and cannot be found on the server.') + expect(@stderr.string).to include("The missing cookbook(s) are:") + expect(@stderr.string).to include("'dependency' version '>= 0.0.0'") + expect(@stderr.string).to include("'dependency2' version '>= 0.0.0'") end end it "should freeze the version of the cookbooks if --freeze is specified" do knife.config[:freeze] = true - cookbook.should_receive(:freeze_version).once + expect(cookbook).to receive(:freeze_version).once knife.run end @@ -248,25 +248,25 @@ E knife.config[:all] = true @test_cookbook1 = Chef::CookbookVersion.new('test_cookbook1', '/tmp/blah') @test_cookbook2 = Chef::CookbookVersion.new('test_cookbook2', '/tmp/blah') - cookbook_loader.stub(:each).and_yield("test_cookbook1", @test_cookbook1).and_yield("test_cookbook2", @test_cookbook2) - cookbook_loader.stub(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2"]) + allow(cookbook_loader).to receive(:each).and_yield("test_cookbook1", @test_cookbook1).and_yield("test_cookbook2", @test_cookbook2) + allow(cookbook_loader).to receive(:cookbook_names).and_return(["test_cookbook1", "test_cookbook2"]) end it 'should upload all cookbooks' do - knife.should_receive(:upload).once + expect(knife).to receive(:upload).once knife.run end it 'should report on success' do - knife.should_receive(:upload).once - knife.ui.should_receive(:info).with(/Uploaded all cookbooks/) + expect(knife).to receive(:upload).once + expect(knife.ui).to receive(:info).with(/Uploaded all cookbooks/) knife.run end it 'should update the version constraints for an environment' do - knife.stub(:assert_environment_valid!).and_return(true) + allow(knife).to receive(:assert_environment_valid!).and_return(true) knife.config[:environment] = "production" - knife.should_receive(:update_version_constraints).once + expect(knife).to receive(:update_version_constraints).once knife.run end end @@ -274,21 +274,21 @@ E describe 'when a frozen cookbook exists on the server' do it 'should fail to replace it' do exception = Chef::Exceptions::CookbookFrozen.new - cookbook_uploader.should_receive(:upload_cookbooks). + expect(cookbook_uploader).to receive(:upload_cookbooks). and_raise(exception) - knife.ui.stub(:error) - knife.ui.should_receive(:error).with(exception) - lambda { knife.run }.should raise_error(SystemExit) + allow(knife.ui).to receive(:error) + expect(knife.ui).to receive(:error).with(exception) + expect { knife.run }.to raise_error(SystemExit) end it 'should not update the version constraints for an environment' do - knife.stub(:assert_environment_valid!).and_return(true) + allow(knife).to receive(:assert_environment_valid!).and_return(true) knife.config[:environment] = "production" - knife.stub(:upload).and_raise(Chef::Exceptions::CookbookFrozen) - knife.ui.should_receive(:error).with(/Failed to upload 1 cookbook/) - knife.ui.should_receive(:warn).with(/Not updating version constraints/) - knife.should_not_receive(:update_version_constraints) - lambda { knife.run }.should raise_error(SystemExit) + allow(knife).to receive(:upload).and_raise(Chef::Exceptions::CookbookFrozen) + expect(knife.ui).to receive(:error).with(/Failed to upload 1 cookbook/) + expect(knife.ui).to receive(:warn).with(/Not updating version constraints/) + expect(knife).not_to receive(:update_version_constraints) + expect { knife.run }.to raise_error(SystemExit) end end end # run diff --git a/spec/unit/knife/core/bootstrap_context_spec.rb b/spec/unit/knife/core/bootstrap_context_spec.rb index cd53088419..1291571358 100644 --- a/spec/unit/knife/core/bootstrap_context_spec.rb +++ b/spec/unit/knife/core/bootstrap_context_spec.rb @@ -35,18 +35,18 @@ describe Chef::Knife::Core::BootstrapContext do subject(:bootstrap_context) { described_class.new(config, run_list, chef_config, secret) } it "runs chef with the first-boot.json in the _default environment" do - bootstrap_context.start_chef.should eq "chef-client -j /etc/chef/first-boot.json -E _default" + expect(bootstrap_context.start_chef).to eq "chef-client -j /etc/chef/first-boot.json -E _default" end describe "when in verbosity mode" do let(:config) { {:verbosity => 2} } it "adds '-l debug' when verbosity is >= 2" do - bootstrap_context.start_chef.should eq "chef-client -j /etc/chef/first-boot.json -l debug -E _default" + expect(bootstrap_context.start_chef).to eq "chef-client -j /etc/chef/first-boot.json -l debug -E _default" end end it "reads the validation key" do - bootstrap_context.validation_key.should eq IO.read(File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem')) + expect(bootstrap_context.validation_key).to eq IO.read(File.join(CHEF_SPEC_DATA, 'ssl', 'private_key.pem')) end it "generates the config file data" do @@ -56,7 +56,7 @@ chef_server_url "http://chef.example.com:4444" validation_client_name "chef-validator-testing" # Using default node name (fqdn) EXPECTED - bootstrap_context.config_content.should eq expected + expect(bootstrap_context.config_content).to eq expected end it "does not set a default log_level" do @@ -66,14 +66,14 @@ EXPECTED describe "alternate chef-client path" do let(:chef_config){ {:chef_client_path => '/usr/local/bin/chef-client'} } it "runs chef-client from another path when specified" do - bootstrap_context.start_chef.should eq "/usr/local/bin/chef-client -j /etc/chef/first-boot.json -E _default" + expect(bootstrap_context.start_chef).to eq "/usr/local/bin/chef-client -j /etc/chef/first-boot.json -E _default" end end describe "validation key path that contains a ~" do let(:chef_config){ {:validation_key => '~/my.key'} } it "reads the validation key when it contains a ~" do - IO.should_receive(:read).with(File.expand_path("my.key", ENV['HOME'])) + expect(IO).to receive(:read).with(File.expand_path("my.key", ENV['HOME'])) bootstrap_context.validation_key end end @@ -81,44 +81,44 @@ EXPECTED describe "when an explicit node name is given" do let(:config){ {:chef_node_name => 'foobar.example.com' }} it "sets the node name in the client.rb" do - bootstrap_context.config_content.should match(/node_name "foobar\.example\.com"/) + expect(bootstrap_context.config_content).to match(/node_name "foobar\.example\.com"/) end end describe "when bootstrapping into a specific environment" do let(:chef_config){ {:environment => "prodtastic"} } it "starts chef in the configured environment" do - bootstrap_context.start_chef.should == 'chef-client -j /etc/chef/first-boot.json -E prodtastic' + expect(bootstrap_context.start_chef).to eq('chef-client -j /etc/chef/first-boot.json -E prodtastic') end end describe "when JSON attributes are given" do let(:config) { {:first_boot_attributes => {:baz => :quux}} } it "adds the attributes to first_boot" do - Chef::JSONCompat.to_json(bootstrap_context.first_boot).should eq(Chef::JSONCompat.to_json({:baz => :quux, :run_list => run_list})) + expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({:baz => :quux, :run_list => run_list})) end end describe "when JSON attributes are NOT given" do it "sets first_boot equal to run_list" do - Chef::JSONCompat.to_json(bootstrap_context.first_boot).should eq(Chef::JSONCompat.to_json({:run_list => run_list})) + expect(Chef::JSONCompat.to_json(bootstrap_context.first_boot)).to eq(Chef::JSONCompat.to_json({:run_list => run_list})) end end describe "when an encrypted_data_bag_secret is provided" do let(:secret) { "supersekret" } it "reads the encrypted_data_bag_secret" do - bootstrap_context.encrypted_data_bag_secret.should eq "supersekret" + expect(bootstrap_context.encrypted_data_bag_secret).to eq "supersekret" end end describe "to support compatibility with existing templates" do it "sets the @config instance variable" do - bootstrap_context.instance_variable_get(:@config).should eq config + expect(bootstrap_context.instance_variable_get(:@config)).to eq config end it "sets the @run_list instance variable" do - bootstrap_context.instance_variable_get(:@run_list).should eq run_list + expect(bootstrap_context.instance_variable_get(:@run_list)).to eq run_list end end @@ -130,7 +130,7 @@ EXPECTED end it "should send the full version to the installer" do - bootstrap_context.latest_current_chef_version_string.should eq("-v 11.12.4") + expect(bootstrap_context.latest_current_chef_version_string).to eq("-v 11.12.4") end end @@ -142,20 +142,20 @@ EXPECTED end it "should send the full version to the installer and set the pre-release flag" do - bootstrap_context.latest_current_chef_version_string.should eq("-v 11.12.4.rc.0 -p") + expect(bootstrap_context.latest_current_chef_version_string).to eq("-v 11.12.4.rc.0 -p") end end describe "when a bootstrap_version is not specified" do it "should send the latest current to the installer" do # Intentionally hard coded in order not to replicate the logic. - bootstrap_context.latest_current_chef_version_string.should eq("-v #{Chef::VERSION.to_i}") + expect(bootstrap_context.latest_current_chef_version_string).to eq("-v #{Chef::VERSION.to_i}") end end describe "ssl_verify_mode" do it "isn't set in the config_content by default" do - bootstrap_context.config_content.should_not include("ssl_verify_mode") + expect(bootstrap_context.config_content).not_to include("ssl_verify_mode") end describe "when configured in config" do @@ -166,14 +166,14 @@ EXPECTED end it "uses the config value" do - bootstrap_context.config_content.should include("ssl_verify_mode :verify_peer") + expect(bootstrap_context.config_content).to include("ssl_verify_mode :verify_peer") end describe "when configured via CLI" do let(:config) {{:node_ssl_verify_mode => "none"}} it "uses CLI value" do - bootstrap_context.config_content.should include("ssl_verify_mode :verify_none") + expect(bootstrap_context.config_content).to include("ssl_verify_mode :verify_none") end end end @@ -181,7 +181,7 @@ EXPECTED describe "verify_api_cert" do it "isn't set in the config_content by default" do - bootstrap_context.config_content.should_not include("verify_api_cert") + expect(bootstrap_context.config_content).not_to include("verify_api_cert") end describe "when configured in config" do @@ -192,14 +192,14 @@ EXPECTED end it "uses the config value" do - bootstrap_context.config_content.should include("verify_api_cert false") + expect(bootstrap_context.config_content).to include("verify_api_cert false") end describe "when configured via CLI" do let(:config) {{:node_verify_api_cert => true}} it "uses CLI value" do - bootstrap_context.config_content.should include("verify_api_cert true") + expect(bootstrap_context.config_content).to include("verify_api_cert true") end end end diff --git a/spec/unit/knife/core/cookbook_scm_repo_spec.rb b/spec/unit/knife/core/cookbook_scm_repo_spec.rb index 69da5400b0..2d66df31c1 100644 --- a/spec/unit/knife/core/cookbook_scm_repo_spec.rb +++ b/spec/unit/knife/core/cookbook_scm_repo_spec.rb @@ -39,45 +39,45 @@ BRANCHES end it "has a path to the cookbook repo" do - @cookbook_repo.repo_path.should == @repo_path + expect(@cookbook_repo.repo_path).to eq(@repo_path) end it "has a default branch" do - @cookbook_repo.default_branch.should == 'master' + expect(@cookbook_repo.default_branch).to eq('master') end describe "when sanity checking the repo" do it "exits when the directory does not exist" do - ::File.should_receive(:directory?).with(@repo_path).and_return(false) - lambda {@cookbook_repo.sanity_check}.should raise_error(SystemExit) + expect(::File).to receive(:directory?).with(@repo_path).and_return(false) + expect {@cookbook_repo.sanity_check}.to raise_error(SystemExit) end describe "and the repo dir exists" do before do - ::File.stub(:directory?).with(@repo_path).and_return(true) + allow(::File).to receive(:directory?).with(@repo_path).and_return(true) end it "exits when there is no git repo" do - ::File.stub(:directory?).with(/.*\.git/).and_return(false) - lambda {@cookbook_repo.sanity_check}.should raise_error(SystemExit) + allow(::File).to receive(:directory?).with(/.*\.git/).and_return(false) + expect {@cookbook_repo.sanity_check}.to raise_error(SystemExit) end describe "and the repo is a git repo" do before do - ::File.stub(:directory?).with(File.join(@repo_path, '.git')).and_return(true) + allow(::File).to receive(:directory?).with(File.join(@repo_path, '.git')).and_return(true) end it "exits when the default branch doesn't exist" do @nobranches = Mixlib::ShellOut.new.tap {|s|s.stdout.replace "\n"} - @cookbook_repo.should_receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@nobranches) - lambda {@cookbook_repo.sanity_check}.should raise_error(SystemExit) + expect(@cookbook_repo).to receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@nobranches) + expect {@cookbook_repo.sanity_check}.to raise_error(SystemExit) end describe "and the default branch exists" do before do @master_branch = Mixlib::ShellOut.new @master_branch.stdout.replace "* master\n" - @cookbook_repo.should_receive(:shell_out!).with("git branch --no-color", :cwd => @repo_path).and_return(@master_branch) + expect(@cookbook_repo).to receive(:shell_out!).with("git branch --no-color", :cwd => @repo_path).and_return(@master_branch) end it "exits when the git repo is dirty" do @@ -85,14 +85,14 @@ BRANCHES @dirty_status.stdout.replace(<<-DIRTY) M chef/lib/chef/knife/cookbook_site_vendor.rb DIRTY - @cookbook_repo.should_receive(:shell_out!).with('git status --porcelain', :cwd => @repo_path).and_return(@dirty_status) - lambda {@cookbook_repo.sanity_check}.should raise_error(SystemExit) + expect(@cookbook_repo).to receive(:shell_out!).with('git status --porcelain', :cwd => @repo_path).and_return(@dirty_status) + expect {@cookbook_repo.sanity_check}.to raise_error(SystemExit) end describe "and the repo is clean" do before do @clean_status = Mixlib::ShellOut.new.tap {|s| s.stdout.replace("\n")} - @cookbook_repo.stub(:shell_out!).with('git status --porcelain', :cwd => @repo_path).and_return(@clean_status) + allow(@cookbook_repo).to receive(:shell_out!).with('git status --porcelain', :cwd => @repo_path).and_return(@clean_status) end it "passes the sanity check" do @@ -106,35 +106,35 @@ DIRTY end it "resets to default state by checking out the default branch" do - @cookbook_repo.should_receive(:shell_out!).with('git checkout master', :cwd => @repo_path) + expect(@cookbook_repo).to receive(:shell_out!).with('git checkout master', :cwd => @repo_path) @cookbook_repo.reset_to_default_state end it "determines if a the pristine copy branch exists" do - @cookbook_repo.should_receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list) - @cookbook_repo.branch_exists?("chef-vendor-apache2").should be_true - @cookbook_repo.should_receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list) - @cookbook_repo.branch_exists?("chef-vendor-nginx").should be_false + expect(@cookbook_repo).to receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list) + expect(@cookbook_repo.branch_exists?("chef-vendor-apache2")).to be_truthy + expect(@cookbook_repo).to receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list) + expect(@cookbook_repo.branch_exists?("chef-vendor-nginx")).to be_falsey end it "determines if a the branch not exists correctly without substring search" do - @cookbook_repo.should_receive(:shell_out!).twice.with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list) - @cookbook_repo.should_not be_branch_exists("chef-vendor-absent") - @cookbook_repo.should be_branch_exists("chef-vendor-absent-new") + expect(@cookbook_repo).to receive(:shell_out!).twice.with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list) + expect(@cookbook_repo).not_to be_branch_exists("chef-vendor-absent") + expect(@cookbook_repo).to be_branch_exists("chef-vendor-absent-new") end describe "when the pristine copy branch does not exist" do it "prepares for import by creating the pristine copy branch" do - @cookbook_repo.should_receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list) - @cookbook_repo.should_receive(:shell_out!).with('git checkout -b chef-vendor-nginx', :cwd => @repo_path) + expect(@cookbook_repo).to receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list) + expect(@cookbook_repo).to receive(:shell_out!).with('git checkout -b chef-vendor-nginx', :cwd => @repo_path) @cookbook_repo.prepare_to_import("nginx") end end describe "when the pristine copy branch does exist" do it "prepares for import by checking out the pristine copy branch" do - @cookbook_repo.should_receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list) - @cookbook_repo.should_receive(:shell_out!).with('git checkout chef-vendor-apache2', :cwd => @repo_path) + expect(@cookbook_repo).to receive(:shell_out!).with('git branch --no-color', :cwd => @repo_path).and_return(@branch_list) + expect(@cookbook_repo).to receive(:shell_out!).with('git checkout chef-vendor-apache2', :cwd => @repo_path) @cookbook_repo.prepare_to_import("apache2") end end @@ -143,15 +143,15 @@ DIRTY before do @updates = Mixlib::ShellOut.new @updates.stdout.replace("\n") - @cookbook_repo.stub(:shell_out!).with('git status --porcelain -- apache2', :cwd => @repo_path).and_return(@updates) + allow(@cookbook_repo).to receive(:shell_out!).with('git status --porcelain -- apache2', :cwd => @repo_path).and_return(@updates) end it "shows no changes in the pristine copy" do - @cookbook_repo.updated?('apache2').should be_false + expect(@cookbook_repo.updated?('apache2')).to be_falsey end it "does nothing to finalize the updates" do - @cookbook_repo.finalize_updates_to('apache2', '1.2.3').should be_false + expect(@cookbook_repo.finalize_updates_to('apache2', '1.2.3')).to be_falsey end end @@ -159,18 +159,18 @@ DIRTY before do @updates = Mixlib::ShellOut.new @updates.stdout.replace(" M cookbooks/apache2/recipes/default.rb\n") - @cookbook_repo.stub(:shell_out!).with('git status --porcelain -- apache2', :cwd => @repo_path).and_return(@updates) + allow(@cookbook_repo).to receive(:shell_out!).with('git status --porcelain -- apache2', :cwd => @repo_path).and_return(@updates) end it "shows changes in the pristine copy" do - @cookbook_repo.updated?('apache2').should be_true + expect(@cookbook_repo.updated?('apache2')).to be_truthy end it "commits the changes to the repo and tags the commit" do - @cookbook_repo.should_receive(:shell_out!).with("git add apache2", :cwd => @repo_path) - @cookbook_repo.should_receive(:shell_out!).with("git commit -m \"Import apache2 version 1.2.3\" -- apache2", :cwd => @repo_path) - @cookbook_repo.should_receive(:shell_out!).with("git tag -f cookbook-site-imported-apache2-1.2.3", :cwd => @repo_path) - @cookbook_repo.finalize_updates_to("apache2", "1.2.3").should be_true + expect(@cookbook_repo).to receive(:shell_out!).with("git add apache2", :cwd => @repo_path) + expect(@cookbook_repo).to receive(:shell_out!).with("git commit -m \"Import apache2 version 1.2.3\" -- apache2", :cwd => @repo_path) + expect(@cookbook_repo).to receive(:shell_out!).with("git tag -f cookbook-site-imported-apache2-1.2.3", :cwd => @repo_path) + expect(@cookbook_repo.finalize_updates_to("apache2", "1.2.3")).to be_truthy end end @@ -180,7 +180,7 @@ DIRTY end it "resets to default state by checking out the default branch" do - @cookbook_repo.should_receive(:shell_out!).with('git checkout develop', :cwd => @repo_path) + expect(@cookbook_repo).to receive(:shell_out!).with('git checkout develop', :cwd => @repo_path) @cookbook_repo.reset_to_default_state end end diff --git a/spec/unit/knife/core/object_loader_spec.rb b/spec/unit/knife/core/object_loader_spec.rb index 53a538da91..67fa858029 100644 --- a/spec/unit/knife/core/object_loader_spec.rb +++ b/spec/unit/knife/core/object_loader_spec.rb @@ -24,17 +24,17 @@ describe Chef::Knife::Core::ObjectLoader do before(:each) do @knife = Chef::Knife.new @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) Dir.chdir(File.join(CHEF_SPEC_DATA, 'object_loader')) end shared_examples_for "Chef object" do |chef_class| it "should create a #{chef_class} object" do - @object.should be_a_kind_of(chef_class) + expect(@object).to be_a_kind_of(chef_class) end it "should has a attribute 'name'" do - @object.name.should eql('test') + expect(@object.name).to eql('test') end end diff --git a/spec/unit/knife/core/subcommand_loader_spec.rb b/spec/unit/knife/core/subcommand_loader_spec.rb index 53664cb528..66c202f680 100644 --- a/spec/unit/knife/core/subcommand_loader_spec.rb +++ b/spec/unit/knife/core/subcommand_loader_spec.rb @@ -20,22 +20,22 @@ require 'spec_helper' describe Chef::Knife::SubcommandLoader do before do - Chef::Platform.stub(:windows?) { false } + allow(Chef::Platform).to receive(:windows?) { false } @home = File.join(CHEF_SPEC_DATA, 'knife-home') @env = {'HOME' => @home} @loader = Chef::Knife::SubcommandLoader.new(File.join(CHEF_SPEC_DATA, 'knife-site-subcommands'), @env) end it "builds a list of the core subcommand file require paths" do - @loader.subcommand_files.should_not be_empty + expect(@loader.subcommand_files).not_to be_empty @loader.subcommand_files.each do |require_path| - require_path.should match(/chef\/knife\/.*|plugins\/knife\/.*/) + expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/) end end it "finds files installed via rubygems" do - @loader.find_subcommands_via_rubygems.should include('chef/knife/node_create') - @loader.find_subcommands_via_rubygems.each {|rel_path, abs_path| abs_path.should match(%r[chef/knife/.+])} + expect(@loader.find_subcommands_via_rubygems).to include('chef/knife/node_create') + @loader.find_subcommands_via_rubygems.each {|rel_path, abs_path| expect(abs_path).to match(%r[chef/knife/.+])} end it "finds files from latest version of installed gems" do @@ -44,33 +44,33 @@ describe Chef::Knife::SubcommandLoader do '/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_base.rb', '/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/ec2_otherstuff.rb' ] - $LOAD_PATH.should_receive(:map).and_return([]) + expect($LOAD_PATH).to receive(:map).and_return([]) if Gem::Specification.respond_to? :latest_specs - Gem::Specification.should_receive(:latest_specs).with(true).and_return(gems) - gems[0].should_receive(:matches_for_glob).with(/chef\/knife\/\*\.rb\{(.*),\.rb,(.*)\}/).and_return(gem_files) + expect(Gem::Specification).to receive(:latest_specs).with(true).and_return(gems) + expect(gems[0]).to receive(:matches_for_glob).with(/chef\/knife\/\*\.rb\{(.*),\.rb,(.*)\}/).and_return(gem_files) else - Gem.source_index.should_receive(:latest_specs).with(true).and_return(gems) - gems[0].should_receive(:require_paths).twice.and_return(['lib']) - gems[0].should_receive(:full_gem_path).and_return('/usr/lib/ruby/gems/knife-ec2-0.5.12') - Dir.should_receive(:[]).with('/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/*.rb').and_return(gem_files) + expect(Gem.source_index).to receive(:latest_specs).with(true).and_return(gems) + expect(gems[0]).to receive(:require_paths).twice.and_return(['lib']) + expect(gems[0]).to receive(:full_gem_path).and_return('/usr/lib/ruby/gems/knife-ec2-0.5.12') + expect(Dir).to receive(:[]).with('/usr/lib/ruby/gems/knife-ec2-0.5.12/lib/chef/knife/*.rb').and_return(gem_files) end - @loader.should_receive(:find_subcommands_via_dirglob).and_return({}) - @loader.find_subcommands_via_rubygems.values.select { |file| file =~ /knife-ec2/ }.sort.should == gem_files + expect(@loader).to receive(:find_subcommands_via_dirglob).and_return({}) + expect(@loader.find_subcommands_via_rubygems.values.select { |file| file =~ /knife-ec2/ }.sort).to eq(gem_files) end it "finds files using a dirglob when rubygems is not available" do - @loader.find_subcommands_via_dirglob.should include('chef/knife/node_create') - @loader.find_subcommands_via_dirglob.each {|rel_path, abs_path| abs_path.should match(%r[chef/knife/.+])} + expect(@loader.find_subcommands_via_dirglob).to include('chef/knife/node_create') + @loader.find_subcommands_via_dirglob.each {|rel_path, abs_path| expect(abs_path).to match(%r[chef/knife/.+])} end it "finds user-specific subcommands in the user's ~/.chef directory" do expected_command = File.join(@home, '.chef', 'plugins', 'knife', 'example_home_subcommand.rb') - @loader.site_subcommands.should include(expected_command) + expect(@loader.site_subcommands).to include(expected_command) end it "finds repo specific subcommands by searching for a .chef directory" do expected_command = File.join(CHEF_SPEC_DATA, 'knife-site-subcommands', 'plugins', 'knife', 'example_subcommand.rb') - @loader.site_subcommands.should include(expected_command) + expect(@loader.site_subcommands).to include(expected_command) end describe "finding 3rd party plugins" do @@ -79,39 +79,39 @@ describe Chef::Knife::SubcommandLoader do before do env_dup = ENV.to_hash - ENV.stub(:[]).and_return { |key| env_dup[key] } - ENV.stub(:[]).with("HOME").and_return(env_home) + allow(ENV).to receive(:[]) { |key| env_dup[key] } + allow(ENV).to receive(:[]).with("HOME").and_return(env_home) end context "when there is not a ~/.chef/plugin_manifest.json file" do before do - File.stub(:exist?).with(manifest_path).and_return(false) + allow(File).to receive(:exist?).with(manifest_path).and_return(false) end it "searches rubygems for plugins" do if Gem::Specification.respond_to?(:latest_specs) - Gem::Specification.should_receive(:latest_specs).and_call_original + expect(Gem::Specification).to receive(:latest_specs).and_call_original else - Gem.source_index.should_receive(:latest_specs).and_call_original + expect(Gem.source_index).to receive(:latest_specs).and_call_original end @loader.subcommand_files.each do |require_path| - require_path.should match(/chef\/knife\/.*|plugins\/knife\/.*/) + expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/) end end context "and HOME environment variable is not set" do before do - ENV.stub(:[]).with("HOME").and_return(nil) + allow(ENV).to receive(:[]).with("HOME").and_return(nil) end it "searches rubygems for plugins" do if Gem::Specification.respond_to?(:latest_specs) - Gem::Specification.should_receive(:latest_specs).and_call_original + expect(Gem::Specification).to receive(:latest_specs).and_call_original else - Gem.source_index.should_receive(:latest_specs).and_call_original + expect(Gem.source_index).to receive(:latest_specs).and_call_original end @loader.subcommand_files.each do |require_path| - require_path.should match(/chef\/knife\/.*|plugins\/knife\/.*/) + expect(require_path).to match(/chef\/knife\/.*|plugins\/knife\/.*/) end end end @@ -135,13 +135,13 @@ describe Chef::Knife::SubcommandLoader do let(:manifest_json) { Chef::JSONCompat.to_json(manifest_content) } before do - File.stub(:exist?).with(manifest_path).and_return(true) - File.stub(:read).with(manifest_path).and_return(manifest_json) + allow(File).to receive(:exist?).with(manifest_path).and_return(true) + allow(File).to receive(:read).with(manifest_path).and_return(manifest_json) end it "uses paths from the manifest instead of searching gems" do - Gem::Specification.should_not_receive(:latest_specs).and_call_original - @loader.subcommand_files.should include(ec2_server_create_plugin) + expect(Gem::Specification).not_to receive(:latest_specs).and_call_original + expect(@loader.subcommand_files).to include(ec2_server_create_plugin) end end diff --git a/spec/unit/knife/core/ui_spec.rb b/spec/unit/knife/core/ui_spec.rb index ed1037ebd5..83fff4c082 100644 --- a/spec/unit/knife/core/ui_spec.rb +++ b/spec/unit/knife/core/ui_spec.rb @@ -67,16 +67,16 @@ describe Chef::Knife::UI do @ui.config[:disable_editing] = false @ui.config[:editor] = my_editor @mock = double('Tempfile') - @mock.should_receive(:sync=).with(true) - @mock.should_receive(:puts).with(json_from_ruby) - @mock.should_receive(:close) - @mock.should_receive(:path).at_least(:once).and_return(temp_path) - Tempfile.should_receive(:open).with([ 'knife-edit-', '.json' ]).and_yield(@mock) + expect(@mock).to receive(:sync=).with(true) + expect(@mock).to receive(:puts).with(json_from_ruby) + expect(@mock).to receive(:close) + expect(@mock).to receive(:path).at_least(:once).and_return(temp_path) + expect(Tempfile).to receive(:open).with([ 'knife-edit-', '.json' ]).and_yield(@mock) end context "and the editor works" do before do - @ui.should_receive(:system).with("#{my_editor} #{temp_path}").and_return(true) - IO.should_receive(:read).with(temp_path).and_return(json_from_editor) + expect(@ui).to receive(:system).with("#{my_editor} #{temp_path}").and_return(true) + expect(IO).to receive(:read).with(temp_path).and_return(json_from_editor) end context "when parse_output is false" do @@ -93,8 +93,8 @@ describe Chef::Knife::UI do end context "when running the editor fails with nil" do before do - @ui.should_receive(:system).with("#{my_editor} #{temp_path}").and_return(nil) - IO.should_not_receive(:read) + expect(@ui).to receive(:system).with("#{my_editor} #{temp_path}").and_return(nil) + expect(IO).not_to receive(:read) end it "throws an exception" do expect{ subject }.to raise_error(RuntimeError) @@ -102,8 +102,8 @@ describe Chef::Knife::UI do end context "when running the editor fails with false" do before do - @ui.should_receive(:system).with("#{my_editor} #{temp_path}").and_return(false) - IO.should_not_receive(:read) + expect(@ui).to receive(:system).with("#{my_editor} #{temp_path}").and_return(false) + expect(IO).not_to receive(:read) end it "throws an exception" do expect{ subject }.to raise_error(RuntimeError) @@ -115,13 +115,13 @@ describe Chef::Knife::UI do @ui.config[:disable_editing] = false @ui.config[:editor] = my_editor @tempfile = Tempfile.new([ 'knife-edit-', '.json' ]) - Tempfile.should_receive(:open).with([ 'knife-edit-', '.json' ]).and_yield(@tempfile) + expect(Tempfile).to receive(:open).with([ 'knife-edit-', '.json' ]).and_yield(@tempfile) end context "and the editor works" do before do - @ui.should_receive(:system).with("#{my_editor} #{@tempfile.path}").and_return(true) - IO.should_receive(:read).with(@tempfile.path).and_return(json_from_editor) + expect(@ui).to receive(:system).with("#{my_editor} #{@tempfile.path}").and_return(true) + expect(IO).to receive(:read).with(@tempfile.path).and_return(json_from_editor) end context "when parse_output is false" do @@ -153,33 +153,33 @@ describe Chef::Knife::UI do describe "format_list_for_display" do it "should print the full hash if --with-uri is true" do @ui.config[:with_uri] = true - @ui.format_list_for_display({ :marcy => :playground }).should == { :marcy => :playground } + expect(@ui.format_list_for_display({ :marcy => :playground })).to eq({ :marcy => :playground }) end it "should print only the keys if --with-uri is false" do @ui.config[:with_uri] = false - @ui.format_list_for_display({ :marcy => :playground }).should == [ :marcy ] + expect(@ui.format_list_for_display({ :marcy => :playground })).to eq([ :marcy ]) end end shared_examples "an output mehthod handling IO exceptions" do |method| it "should throw Errno::EIO exceptions" do - @out.stub(:puts).and_raise(Errno::EIO) - @err.stub(:puts).and_raise(Errno::EIO) - lambda {@ui.send(method, "hi")}.should raise_error(Errno::EIO) + allow(@out).to receive(:puts).and_raise(Errno::EIO) + allow(@err).to receive(:puts).and_raise(Errno::EIO) + expect {@ui.send(method, "hi")}.to raise_error(Errno::EIO) end it "should ignore Errno::EPIPE exceptions (CHEF-3516)" do - @out.stub(:puts).and_raise(Errno::EPIPE) - @err.stub(:puts).and_raise(Errno::EPIPE) - lambda {@ui.send(method, "hi")}.should raise_error(SystemExit) + allow(@out).to receive(:puts).and_raise(Errno::EPIPE) + allow(@err).to receive(:puts).and_raise(Errno::EPIPE) + expect {@ui.send(method, "hi")}.to raise_error(SystemExit) end it "should throw Errno::EPIPE exceptions with -VV (CHEF-3516)" do @config[:verbosity] = 2 - @out.stub(:puts).and_raise(Errno::EPIPE) - @err.stub(:puts).and_raise(Errno::EPIPE) - lambda {@ui.send(method, "hi")}.should raise_error(Errno::EPIPE) + allow(@out).to receive(:puts).and_raise(Errno::EPIPE) + allow(@err).to receive(:puts).and_raise(Errno::EPIPE) + expect {@ui.send(method, "hi")}.to raise_error(Errno::EPIPE) end end @@ -188,12 +188,12 @@ describe Chef::Knife::UI do it "formats strings appropriately" do @ui.output("hi") - @out.string.should == "hi\n" + expect(@out.string).to eq("hi\n") end it "formats hashes appropriately" do @ui.output({'hi' => 'a', 'lo' => 'b' }) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM hi: a lo: b EOM @@ -201,12 +201,12 @@ EOM it "formats empty hashes appropriately" do @ui.output({}) - @out.string.should == "\n" + expect(@out.string).to eq("\n") end it "formats arrays appropriately" do @ui.output([ 'a', 'b' ]) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM a b EOM @@ -214,22 +214,22 @@ EOM it "formats empty arrays appropriately" do @ui.output([ ]) - @out.string.should == "\n" + expect(@out.string).to eq("\n") end it "formats single-member arrays appropriately" do @ui.output([ 'a' ]) - @out.string.should == "a\n" + expect(@out.string).to eq("a\n") end it "formats nested single-member arrays appropriately" do @ui.output([ [ 'a' ] ]) - @out.string.should == "a\n" + expect(@out.string).to eq("a\n") end it "formats nested arrays appropriately" do @ui.output([ [ 'a', 'b' ], [ 'c', 'd' ]]) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM a b @@ -240,7 +240,7 @@ EOM it "formats nested arrays with single- and empty subarrays appropriately" do @ui.output([ [ 'a', 'b' ], [ 'c' ], [], [ 'd', 'e' ]]) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM a b @@ -254,7 +254,7 @@ EOM it "formats arrays of hashes with extra lines in between for readability" do @ui.output([ { 'a' => 'b', 'c' => 'd' }, { 'x' => 'y' }, { 'm' => 'n', 'o' => 'p' }]) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM a: b c: d @@ -267,7 +267,7 @@ EOM it "formats hashes with empty array members appropriately" do @ui.output({ 'a' => [], 'b' => 'c' }) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM a: b: c EOM @@ -275,7 +275,7 @@ EOM it "formats hashes with single-member array values appropriately" do @ui.output({ 'a' => [ 'foo' ], 'b' => 'c' }) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM a: foo b: c EOM @@ -283,7 +283,7 @@ EOM it "formats hashes with array members appropriately" do @ui.output({ 'a' => [ 'foo', 'bar' ], 'b' => 'c' }) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM a: foo bar @@ -293,7 +293,7 @@ EOM it "formats hashes with single-member nested array values appropriately" do @ui.output({ 'a' => [ [ 'foo' ] ], 'b' => 'c' }) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM a: foo b: c @@ -304,12 +304,12 @@ EOM @ui.output({ 'a' => [ [ 'foo', 'bar' ], [ 'baz', 'bjork' ] ], 'b' => 'c' }) # XXX: using a HEREDOC at this point results in a line with required spaces which auto-whitespace removal settings # on editors will remove and will break this test. - @out.string.should == "a:\n foo\n bar\n \n baz\n bjork\nb: c\n" + expect(@out.string).to eq("a:\n foo\n bar\n \n baz\n bjork\nb: c\n") end it "formats hashes with hash values appropriately" do @ui.output({ 'a' => { 'aa' => 'bb', 'cc' => 'dd' }, 'b' => 'c' }) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM a: aa: bb cc: dd @@ -319,7 +319,7 @@ EOM it "formats hashes with empty hash values appropriately" do @ui.output({ 'a' => { }, 'b' => 'c' }) - @out.string.should == <<EOM + expect(@out.string).to eq <<EOM a: b: c EOM @@ -341,20 +341,20 @@ EOM describe "format_for_display" do it "should return the raw data" do input = { :gi => :go } - @ui.format_for_display(input).should == input + expect(@ui.format_for_display(input)).to eq(input) end describe "with --attribute passed" do it "should return the deeply nested attribute" do input = { "gi" => { "go" => "ge" }, "id" => "sample-data-bag-item" } @ui.config[:attribute] = "gi.go" - @ui.format_for_display(input).should == { "sample-data-bag-item" => { "gi.go" => "ge" } } + expect(@ui.format_for_display(input)).to eq({ "sample-data-bag-item" => { "gi.go" => "ge" } }) end it "should return multiple attributes" do input = { "gi" => "go", "hi" => "ho", "id" => "sample-data-bag-item" } @ui.config[:attribute] = ["gi", "hi"] - @ui.format_for_display(input).should == { "sample-data-bag-item" => { "gi" => "go", "hi"=> "ho" } } + expect(@ui.format_for_display(input)).to eq({ "sample-data-bag-item" => { "gi" => "go", "hi"=> "ho" } }) end end @@ -365,8 +365,8 @@ EOM input.run_list("role[monkey]", "role[churchmouse]") @ui.config[:run_list] = true response = @ui.format_for_display(input) - response["sample-node"]["run_list"][0].should == "role[monkey]" - response["sample-node"]["run_list"][1].should == "role[churchmouse]" + expect(response["sample-node"]["run_list"][0]).to eq("role[monkey]") + expect(response["sample-node"]["run_list"][1]).to eq("role[churchmouse]") end end end @@ -388,7 +388,7 @@ EOM it "should return an array of the cookbooks with versions" do expected_response = [ "cookbook_name 3.0.0 2.0.0 1.0.0" ] response = @ui.format_cookbook_list_for_display(@item) - response.should == expected_response + expect(response).to eq(expected_response) end describe "with --with-uri" do @@ -400,15 +400,15 @@ EOM "3.0.0" => "http://url/cookbooks/3.0.0"} } @ui.config[:with_uri] = true - @ui.format_cookbook_list_for_display(@item).should == response + expect(@ui.format_cookbook_list_for_display(@item)).to eq(response) end end context "when running on Windows" do before(:each) do stdout = double('StringIO', :tty? => true) - @ui.stub(:stdout).and_return(stdout) - Chef::Platform.stub(:windows?) { true } + allow(@ui).to receive(:stdout).and_return(stdout) + allow(Chef::Platform).to receive(:windows?) { true } Chef::Config.reset end @@ -444,36 +444,36 @@ EOM let(:append_instructions) { true } def run_confirm - @ui.stub(:stdout).and_return(stdout) - @ui.stdin.stub(:readline).and_return(answer) + allow(@ui).to receive(:stdout).and_return(stdout) + allow(@ui.stdin).to receive(:readline).and_return(answer) @ui.confirm(question, append_instructions, default_choice) end def run_confirm_without_exit - @ui.stub(:stdout).and_return(stdout) - @ui.stdin.stub(:readline).and_return(answer) + allow(@ui).to receive(:stdout).and_return(stdout) + allow(@ui.stdin).to receive(:readline).and_return(answer) @ui.confirm_without_exit(question, append_instructions, default_choice) end shared_examples_for "confirm with positive answer" do it "confirm should return true" do - run_confirm.should be_true + expect(run_confirm).to be_truthy end it "confirm_without_exit should return true" do - run_confirm_without_exit.should be_true + expect(run_confirm_without_exit).to be_truthy end end shared_examples_for "confirm with negative answer" do it "confirm should exit 3" do - lambda { + expect { run_confirm - }.should raise_error(SystemExit) { |e| e.status.should == 3 } + }.to raise_error(SystemExit) { |e| expect(e.status).to eq(3) } end it "confirm_without_exit should return false" do - run_confirm_without_exit.should be_false + expect(run_confirm_without_exit).to be_falsey end end @@ -482,7 +482,7 @@ EOM it "should show 'Y/n' in the instructions" do run_confirm - output.should include("Y/n") + expect(output).to include("Y/n") end describe "with empty answer" do @@ -503,7 +503,7 @@ EOM it "should show 'y/N' in the instructions" do run_confirm - output.should include("y/N") + expect(output).to include("y/N") end describe "with empty answer" do @@ -538,8 +538,8 @@ EOM describe "with --y or --yes passed" do it "should return true" do @ui.config[:yes] = true - run_confirm.should be_true - output.should eq("") + expect(run_confirm).to be_truthy + expect(output).to eq("") end end end @@ -547,18 +547,18 @@ EOM describe "when asking for free-form user input" do it "asks a question and returns the answer provided by the user" do out = StringIO.new - @ui.stub(:stdout).and_return(out) - @ui.stub(:stdin).and_return(StringIO.new("http://mychefserver.example.com\n")) - @ui.ask_question("your chef server URL?").should == "http://mychefserver.example.com" - out.string.should == "your chef server URL?" + allow(@ui).to receive(:stdout).and_return(out) + allow(@ui).to receive(:stdin).and_return(StringIO.new("http://mychefserver.example.com\n")) + expect(@ui.ask_question("your chef server URL?")).to eq("http://mychefserver.example.com") + expect(out.string).to eq("your chef server URL?") end it "suggests a default setting and returns the default when the user's response only contains whitespace" do out = StringIO.new - @ui.stub(:stdout).and_return(out) - @ui.stub(:stdin).and_return(StringIO.new(" \n")) - @ui.ask_question("your chef server URL? ", :default => 'http://localhost:4000').should == "http://localhost:4000" - out.string.should == "your chef server URL? [http://localhost:4000] " + allow(@ui).to receive(:stdout).and_return(out) + allow(@ui).to receive(:stdin).and_return(StringIO.new(" \n")) + expect(@ui.ask_question("your chef server URL? ", :default => 'http://localhost:4000')).to eq("http://localhost:4000") + expect(out.string).to eq("your chef server URL? [http://localhost:4000] ") end end diff --git a/spec/unit/knife/data_bag_from_file_spec.rb b/spec/unit/knife/data_bag_from_file_spec.rb index 8de046e7a4..3882bff349 100644 --- a/spec/unit/knife/data_bag_from_file_spec.rb +++ b/spec/unit/knife/data_bag_from_file_spec.rb @@ -26,7 +26,7 @@ Chef::Knife::DataBagFromFile.load_deps describe Chef::Knife::DataBagFromFile do before :each do - Chef::Platform.stub(:windows?) { false } + allow(Chef::Platform).to receive(:windows?) { false } Chef::Config[:node_name] = "webmonkey.example.com" FileUtils.mkdir_p([db_folder, db_folder2]) db_file.write(Chef::JSONCompat.to_json(plain_data)) diff --git a/spec/unit/knife/environment_compare_spec.rb b/spec/unit/knife/environment_compare_spec.rb index 3606b617a9..6d4d3ead52 100644 --- a/spec/unit/knife/environment_compare_spec.rb +++ b/spec/unit/knife/environment_compare_spec.rb @@ -27,21 +27,21 @@ describe Chef::Knife::EnvironmentCompare do "citm" => "http://localhost:4000/environments/citm" } - @knife.stub(:environment_list).and_return(@environments) + allow(@knife).to receive(:environment_list).and_return(@environments) @constraints = { "cita" => { "foo" => "= 1.0.1", "bar" => "= 0.0.4" }, "citm" => { "foo" => "= 1.0.1", "bar" => "= 0.0.2" } } - @knife.stub(:constraint_list).and_return(@constraints) + allow(@knife).to receive(:constraint_list).and_return(@constraints) @cookbooks = { "foo"=>"= 1.0.1", "bar"=>"= 0.0.1" } - @knife.stub(:cookbook_list).and_return(@cookbooks) + allow(@knife).to receive(:cookbook_list).and_return(@cookbooks) @rest_double = double('rest') - @knife.stub(:rest).and_return(@rest_double) + allow(@knife).to receive(:rest).and_return(@rest_double) @cookbook_names = ['apache2', 'mysql', 'foo', 'bar', 'dummy', 'chef_handler'] @base_url = 'https://server.example.com/cookbooks' @cookbook_data = {} @@ -51,10 +51,10 @@ describe Chef::Knife::EnvironmentCompare do 'url' => "#{@base_url}/#{item}/1.0.1"}]} end - @rest_double.stub(:get_rest).with("/cookbooks?num_versions=1").and_return(@cookbook_data) + allow(@rest_double).to receive(:get_rest).with("/cookbooks?num_versions=1").and_return(@cookbook_data) @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe 'run' do @@ -62,14 +62,14 @@ describe Chef::Knife::EnvironmentCompare do @knife.config[:format] = 'summary' @knife.run @environments.each do |item, url| - @stdout.string.should match /#{item}/ and @stdout.string.lines.count.should be 4 + expect(@stdout.string).to match /#{item}/ and expect(@stdout.string.lines.count).to be 4 end end it 'should display 4 number of lines' do @knife.config[:format] = 'summary' @knife.run - @stdout.string.lines.count.should be 4 + expect(@stdout.string.lines.count).to be 4 end end @@ -79,7 +79,7 @@ describe Chef::Knife::EnvironmentCompare do @knife.config[:mismatch] = true @knife.run @constraints.each do |item, ver| - @stdout.string.should match /#{ver[1]}/ + expect(@stdout.string).to match /#{ver[1]}/ end end @@ -87,7 +87,7 @@ describe Chef::Knife::EnvironmentCompare do @knife.config[:format] = 'summary' @knife.config[:mismatch] = true @knife.run - @stdout.string.lines.count.should be 3 + expect(@stdout.string.lines.count).to be 3 end end @@ -97,7 +97,7 @@ describe Chef::Knife::EnvironmentCompare do @knife.config[:all] = true @knife.run @constraints.each do |item, ver| - @stdout.string.should match /#{ver[1]}/ + expect(@stdout.string).to match /#{ver[1]}/ end end @@ -105,7 +105,7 @@ describe Chef::Knife::EnvironmentCompare do @knife.config[:format] = 'summary' @knife.config[:all] = true @knife.run - @stdout.string.lines.count.should be 8 + expect(@stdout.string.lines.count).to be 8 end end diff --git a/spec/unit/knife/environment_create_spec.rb b/spec/unit/knife/environment_create_spec.rb index 81bf6731b7..04e45048ef 100644 --- a/spec/unit/knife/environment_create_spec.rb +++ b/spec/unit/knife/environment_create_spec.rb @@ -21,49 +21,49 @@ require 'spec_helper' describe Chef::Knife::EnvironmentCreate do before(:each) do @knife = Chef::Knife::EnvironmentCreate.new - @knife.stub(:msg).and_return true - @knife.stub(:output).and_return true - @knife.stub(:show_usage).and_return true + allow(@knife).to receive(:msg).and_return true + allow(@knife).to receive(:output).and_return true + allow(@knife).to receive(:show_usage).and_return true @knife.name_args = [ "production" ] @environment = Chef::Environment.new - @environment.stub(:save) + allow(@environment).to receive(:save) - Chef::Environment.stub(:new).and_return @environment - @knife.stub(:edit_data).and_return @environment + allow(Chef::Environment).to receive(:new).and_return @environment + allow(@knife).to receive(:edit_data).and_return @environment end describe "run" do it "should create a new environment" do - Chef::Environment.should_receive(:new) + expect(Chef::Environment).to receive(:new) @knife.run end it "should set the environment name" do - @environment.should_receive(:name).with("production") + expect(@environment).to receive(:name).with("production") @knife.run end it "should not print the environment" do - @knife.should_not_receive(:output) + expect(@knife).not_to receive(:output) @knife.run end it "should prompt you to edit the data" do - @knife.should_receive(:edit_data).with(@environment) + expect(@knife).to receive(:edit_data).with(@environment) @knife.run end it "should save the environment" do - @environment.should_receive(:save) + expect(@environment).to receive(:save) @knife.run end it "should show usage and exit when no environment name is provided" do @knife.name_args = [ ] - @knife.ui.should_receive(:fatal) - @knife.should_receive(:show_usage) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:fatal) + expect(@knife).to receive(:show_usage) + expect { @knife.run }.to raise_error(SystemExit) end describe "with --description" do @@ -72,7 +72,7 @@ describe Chef::Knife::EnvironmentCreate do end it "should set the description" do - @environment.should_receive(:description).with("This is production") + expect(@environment).to receive(:description).with("This is production") @knife.run end end @@ -83,7 +83,7 @@ describe Chef::Knife::EnvironmentCreate do end it "should pretty print the environment, formatted for display" do - @knife.should_receive(:output).with(@environment) + expect(@knife).to receive(:output).with(@environment) @knife.run end end diff --git a/spec/unit/knife/environment_delete_spec.rb b/spec/unit/knife/environment_delete_spec.rb index 0f6b5f3272..95df6e15fe 100644 --- a/spec/unit/knife/environment_delete_spec.rb +++ b/spec/unit/knife/environment_delete_spec.rb @@ -21,50 +21,50 @@ require 'spec_helper' describe Chef::Knife::EnvironmentDelete do before(:each) do @knife = Chef::Knife::EnvironmentDelete.new - @knife.stub(:msg).and_return true - @knife.stub(:output).and_return true - @knife.stub(:show_usage).and_return true - @knife.stub(:confirm).and_return true + allow(@knife).to receive(:msg).and_return true + allow(@knife).to receive(:output).and_return true + allow(@knife).to receive(:show_usage).and_return true + allow(@knife).to receive(:confirm).and_return true @knife.name_args = [ "production" ] @environment = Chef::Environment.new @environment.name("production") @environment.description("Please delete me") - @environment.stub(:destroy).and_return true - Chef::Environment.stub(:load).and_return @environment + allow(@environment).to receive(:destroy).and_return true + allow(Chef::Environment).to receive(:load).and_return @environment end it "should confirm that you want to delete" do - @knife.should_receive(:confirm) + expect(@knife).to receive(:confirm) @knife.run end it "should load the environment" do - Chef::Environment.should_receive(:load).with("production") + expect(Chef::Environment).to receive(:load).with("production") @knife.run end it "should delete the environment" do - @environment.should_receive(:destroy) + expect(@environment).to receive(:destroy) @knife.run end it "should not print the environment" do - @knife.should_not_receive(:output) + expect(@knife).not_to receive(:output) @knife.run end it "should show usage and exit when no environment name is provided" do @knife.name_args = [] - @knife.ui.should_receive(:fatal) - @knife.should_receive(:show_usage) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:fatal) + expect(@knife).to receive(:show_usage) + expect { @knife.run }.to raise_error(SystemExit) end describe "with --print-after" do it "should pretty print the environment, formatted for display" do @knife.config[:print_after] = true - @knife.should_receive(:output).with(@environment) + expect(@knife).to receive(:output).with(@environment) @knife.run end end diff --git a/spec/unit/knife/environment_edit_spec.rb b/spec/unit/knife/environment_edit_spec.rb index a82ead0b6b..61c2663a41 100644 --- a/spec/unit/knife/environment_edit_spec.rb +++ b/spec/unit/knife/environment_edit_spec.rb @@ -21,26 +21,26 @@ require 'spec_helper' describe Chef::Knife::EnvironmentEdit do before(:each) do @knife = Chef::Knife::EnvironmentEdit.new - @knife.ui.stub(:msg).and_return true - @knife.ui.stub(:output).and_return true - @knife.ui.stub(:show_usage).and_return true + allow(@knife.ui).to receive(:msg).and_return true + allow(@knife.ui).to receive(:output).and_return true + allow(@knife.ui).to receive(:show_usage).and_return true @knife.name_args = [ "production" ] @environment = Chef::Environment.new @environment.name("production") @environment.description("Please edit me") - @environment.stub(:save).and_return true - Chef::Environment.stub(:load).and_return @environment - @knife.ui.stub(:edit_data).and_return @environment + allow(@environment).to receive(:save).and_return true + allow(Chef::Environment).to receive(:load).and_return @environment + allow(@knife.ui).to receive(:edit_data).and_return @environment end it "should load the environment" do - Chef::Environment.should_receive(:load).with("production") + expect(Chef::Environment).to receive(:load).with("production") @knife.run end it "should let you edit the environment" do - @knife.ui.should_receive(:edit_data).with(@environment) + expect(@knife.ui).to receive(:edit_data).with(@environment) @knife.run end @@ -48,31 +48,31 @@ describe Chef::Knife::EnvironmentEdit do pansy = Chef::Environment.new @environment.name("new_environment_name") - @knife.ui.should_receive(:edit_data).with(@environment).and_return(pansy) - pansy.should_receive(:save) + expect(@knife.ui).to receive(:edit_data).with(@environment).and_return(pansy) + expect(pansy).to receive(:save) @knife.run end it "should not save the unedited environment data" do - @environment.should_not_receive(:save) + expect(@environment).not_to receive(:save) @knife.run end it "should not print the environment" do - @knife.should_not_receive(:output) + expect(@knife).not_to receive(:output) @knife.run end it "shoud show usage and exit when no environment name is provided" do @knife.name_args = [] - @knife.should_receive(:show_usage) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect { @knife.run }.to raise_error(SystemExit) end describe "with --print-after" do it "should pretty print the environment, formatted for display" do @knife.config[:print_after] = true - @knife.ui.should_receive(:output).with(@environment) + expect(@knife.ui).to receive(:output).with(@environment) @knife.run end end diff --git a/spec/unit/knife/environment_from_file_spec.rb b/spec/unit/knife/environment_from_file_spec.rb index 562e7f8cf5..d150e5ee64 100644 --- a/spec/unit/knife/environment_from_file_spec.rb +++ b/spec/unit/knife/environment_from_file_spec.rb @@ -23,24 +23,24 @@ Chef::Knife::EnvironmentFromFile.load_deps describe Chef::Knife::EnvironmentFromFile do before(:each) do - Chef::Platform.stub(:windows?) { false } + allow(Chef::Platform).to receive(:windows?) { false } @knife = Chef::Knife::EnvironmentFromFile.new @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) @knife.name_args = [ "spec.rb" ] @environment = Chef::Environment.new @environment.name("spec") @environment.description("runs the unit tests") @environment.cookbook_versions({"apt" => "= 1.2.3"}) - @environment.stub(:save).and_return true - @knife.loader.stub(:load_from).and_return @environment + allow(@environment).to receive(:save).and_return true + allow(@knife.loader).to receive(:load_from).and_return @environment end describe "run" do it "loads the environment data from a file and saves it" do - @knife.loader.should_receive(:load_from).with('environments', 'spec.rb').and_return(@environment) - @environment.should_receive(:save) + expect(@knife.loader).to receive(:load_from).with('environments', 'spec.rb').and_return(@environment) + expect(@environment).to receive(:save) @knife.run end @@ -48,41 +48,41 @@ describe Chef::Knife::EnvironmentFromFile do before(:each) do @env_apple = @environment.dup @env_apple.name("apple") - @knife.loader.stub(:load_from).with("apple.rb").and_return @env_apple + allow(@knife.loader).to receive(:load_from).with("apple.rb").and_return @env_apple end it "loads multiple environments if given" do @knife.name_args = [ "spec.rb", "apple.rb" ] - @environment.should_receive(:save).twice + expect(@environment).to receive(:save).twice @knife.run end it "loads all environments with -a" do - File.stub(:expand_path).with("./environments/").and_return("/tmp/environments") - Dir.stub(:glob).with("/tmp/environments/*.{json,rb}").and_return(["spec.rb", "apple.rb"]) + allow(File).to receive(:expand_path).with("./environments/").and_return("/tmp/environments") + allow(Dir).to receive(:glob).with("/tmp/environments/*.{json,rb}").and_return(["spec.rb", "apple.rb"]) @knife.name_args = [] - @knife.stub(:config).and_return({:all => true}) - @environment.should_receive(:save).twice + allow(@knife).to receive(:config).and_return({:all => true}) + expect(@environment).to receive(:save).twice @knife.run end end it "should not print the environment" do - @knife.should_not_receive(:output) + expect(@knife).not_to receive(:output) @knife.run end it "should show usage and exit if not filename is provided" do @knife.name_args = [] - @knife.ui.should_receive(:fatal) - @knife.should_receive(:show_usage) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:fatal) + expect(@knife).to receive(:show_usage) + expect { @knife.run }.to raise_error(SystemExit) end describe "with --print-after" do it "should pretty print the environment, formatted for display" do @knife.config[:print_after] = true - @knife.should_receive(:output) + expect(@knife).to receive(:output) @knife.run end end diff --git a/spec/unit/knife/environment_list_spec.rb b/spec/unit/knife/environment_list_spec.rb index 25d2714d23..6488a073b6 100644 --- a/spec/unit/knife/environment_list_spec.rb +++ b/spec/unit/knife/environment_list_spec.rb @@ -21,33 +21,33 @@ require 'spec_helper' describe Chef::Knife::EnvironmentList do before(:each) do @knife = Chef::Knife::EnvironmentList.new - @knife.stub(:msg).and_return true - @knife.stub(:output).and_return true - @knife.stub(:show_usage).and_return true + allow(@knife).to receive(:msg).and_return true + allow(@knife).to receive(:output).and_return true + allow(@knife).to receive(:show_usage).and_return true @environments = { "production" => "http://localhost:4000/environments/production", "development" => "http://localhost:4000/environments/development", "testing" => "http://localhost:4000/environments/testing" } - Chef::Environment.stub(:list).and_return @environments + allow(Chef::Environment).to receive(:list).and_return @environments end it "should make an api call to list the environments" do - Chef::Environment.should_receive(:list) + expect(Chef::Environment).to receive(:list) @knife.run end it "should print the environment names in a sorted list" do names = @environments.keys.sort { |a,b| a <=> b } - @knife.should_receive(:output).with(names) + expect(@knife).to receive(:output).with(names) @knife.run end describe "with --with-uri" do it "should print and unsorted list of the environments and their URIs" do @knife.config[:with_uri] = true - @knife.should_receive(:output).with(@environments) + expect(@knife).to receive(:output).with(@environments) @knife.run end end diff --git a/spec/unit/knife/environment_show_spec.rb b/spec/unit/knife/environment_show_spec.rb index c7b0c21657..caac958f8e 100644 --- a/spec/unit/knife/environment_show_spec.rb +++ b/spec/unit/knife/environment_show_spec.rb @@ -21,32 +21,32 @@ require 'spec_helper' describe Chef::Knife::EnvironmentShow do before(:each) do @knife = Chef::Knife::EnvironmentShow.new - @knife.stub(:msg).and_return true - @knife.stub(:output).and_return true - @knife.stub(:show_usage).and_return true + allow(@knife).to receive(:msg).and_return true + allow(@knife).to receive(:output).and_return true + allow(@knife).to receive(:show_usage).and_return true @knife.name_args = [ "production" ] @environment = Chef::Environment.new @environment.name("production") @environment.description("Look at me!") - Chef::Environment.stub(:load).and_return @environment + allow(Chef::Environment).to receive(:load).and_return @environment end it "should load the environment" do - Chef::Environment.should_receive(:load).with("production") + expect(Chef::Environment).to receive(:load).with("production") @knife.run end it "should pretty print the environment, formatted for display" do - @knife.should_receive(:format_for_display).with(@environment) - @knife.should_receive(:output) + expect(@knife).to receive(:format_for_display).with(@environment) + expect(@knife).to receive(:output) @knife.run end it "should show usage and exit when no environment name is provided" do @knife.name_args = [] - @knife.ui.should_receive(:fatal) - @knife.should_receive(:show_usage) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:fatal) + expect(@knife).to receive(:show_usage) + expect { @knife.run }.to raise_error(SystemExit) end end diff --git a/spec/unit/knife/index_rebuild_spec.rb b/spec/unit/knife/index_rebuild_spec.rb index 3a8ec00651..6c3b60bd88 100644 --- a/spec/unit/knife/index_rebuild_spec.rb +++ b/spec/unit/knife/index_rebuild_spec.rb @@ -24,18 +24,18 @@ describe Chef::Knife::IndexRebuild do let(:rest_client){double(Chef::REST)} let(:stub_rest!) do - knife.should_receive(:rest).and_return(rest_client) + expect(knife).to receive(:rest).and_return(rest_client) end before :each do # This keeps the test output clean - knife.ui.stub(:stdout).and_return(StringIO.new) + allow(knife.ui).to receive(:stdout).and_return(StringIO.new) end context "#grab_api_info" do let(:http_not_found_response) do e = Net::HTTPNotFound.new("1.1", 404, "blah") - e.stub(:[]).with("x-ops-api-info").and_return(api_header_value) + allow(e).to receive(:[]).with("x-ops-api-info").and_return(api_header_value) e end @@ -45,20 +45,20 @@ describe Chef::Knife::IndexRebuild do before(:each) do stub_rest! - rest_client.stub(:get_rest).and_raise(http_server_exception) + allow(rest_client).to receive(:get_rest).and_raise(http_server_exception) end context "against a Chef 11 server" do let(:api_header_value){"flavor=osc;version=11.0.0;erchef=1.2.3"} it "retrieves API information" do - knife.grab_api_info.should == {"flavor" => "osc", "version" => "11.0.0", "erchef" => "1.2.3"} + expect(knife.grab_api_info).to eq({"flavor" => "osc", "version" => "11.0.0", "erchef" => "1.2.3"}) end end # Chef 11 context "against a Chef 10 server" do let(:api_header_value){nil} it "finds no API information" do - knife.grab_api_info.should == {} + expect(knife.grab_api_info).to eq({}) end end # Chef 10 end # grab_api_info @@ -66,18 +66,18 @@ describe Chef::Knife::IndexRebuild do context "#unsupported_version?" do context "with Chef 11 API metadata" do it "is unsupported" do - knife.unsupported_version?({"version" => "11.0.0", "flavor" => "osc", "erchef" => "1.2.3"}).should be_true + expect(knife.unsupported_version?({"version" => "11.0.0", "flavor" => "osc", "erchef" => "1.2.3"})).to be_truthy end it "only truly relies on the version being non-nil" do - knife.unsupported_version?({"version" => "1", "flavor" => "osc", "erchef" => "1.2.3"}).should be_true + expect(knife.unsupported_version?({"version" => "1", "flavor" => "osc", "erchef" => "1.2.3"})).to be_truthy end end context "with Chef 10 API metadata" do it "is supported" do # Chef 10 will have no metadata - knife.unsupported_version?({}).should be_false + expect(knife.unsupported_version?({})).to be_falsey end end end # unsupported_version? @@ -85,7 +85,7 @@ describe Chef::Knife::IndexRebuild do context "Simulating a 'knife index rebuild' run" do before :each do - knife.should_receive(:grab_api_info).and_return(api_info) + expect(knife).to receive(:grab_api_info).and_return(api_info) server_specific_stubs! end @@ -97,8 +97,8 @@ describe Chef::Knife::IndexRebuild do } end let(:server_specific_stubs!) do - knife.should_receive(:unsupported_server_message).with(api_info) - knife.should_receive(:exit).with(1) + expect(knife).to receive(:unsupported_server_message).with(api_info) + expect(knife).to receive(:exit).with(1) end it "should not be allowed" do @@ -110,11 +110,11 @@ describe Chef::Knife::IndexRebuild do let(:api_info){ {} } let(:server_specific_stubs!) do stub_rest! - rest_client.should_receive(:post_rest).with("/search/reindex", {}).and_return("representative output") - knife.should_not_receive(:unsupported_server_message) - knife.should_receive(:deprecated_server_message) - knife.should_receive(:nag) - knife.should_receive(:output).with("representative output") + expect(rest_client).to receive(:post_rest).with("/search/reindex", {}).and_return("representative output") + expect(knife).not_to receive(:unsupported_server_message) + expect(knife).to receive(:deprecated_server_message) + expect(knife).to receive(:nag) + expect(knife).to receive(:output).with("representative output") end it "should be allowed" do knife.run diff --git a/spec/unit/knife/knife_help.rb b/spec/unit/knife/knife_help.rb index e66a44801b..293bae17f4 100644 --- a/spec/unit/knife/knife_help.rb +++ b/spec/unit/knife/knife_help.rb @@ -26,66 +26,66 @@ describe Chef::Knife::Help do end it "should return a list of help topics" do - @knife.help_topics.should include("knife-status") + expect(@knife.help_topics).to include("knife-status") end it "should run man for you" do @knife.name_args = [ "shell" ] - @knife.should_receive(:exec).with(/^man \/.*\/shell.1$/) + expect(@knife).to receive(:exec).with(/^man \/.*\/shell.1$/) @knife.run end it "should suggest topics" do @knife.name_args = [ "list" ] - @knife.ui.stub(:msg) - @knife.ui.should_receive(:info).with("Available help topics are: ") - @knife.ui.should_receive(:msg).with(/knife/) - @knife.stub(:exec) - @knife.should_receive(:exit).with(1) + allow(@knife.ui).to receive(:msg) + expect(@knife.ui).to receive(:info).with("Available help topics are: ") + expect(@knife.ui).to receive(:msg).with(/knife/) + allow(@knife).to receive(:exec) + expect(@knife).to receive(:exit).with(1) @knife.run end describe "find_manpage_path" do it "should find the man page in the gem" do - @knife.find_manpage_path("shell").should =~ /distro\/common\/man\/man1\/chef-shell.1$/ + expect(@knife.find_manpage_path("shell")).to match(/distro\/common\/man\/man1\/chef-shell.1$/) end it "should provide the man page name if not in the gem" do - @knife.find_manpage_path("foo").should == "foo" + expect(@knife.find_manpage_path("foo")).to eq("foo") end end describe "find_manpages_for_query" do it "should error if it does not find a match" do - @knife.ui.stub(:error) - @knife.ui.stub(:info) - @knife.ui.stub(:msg) - @knife.should_receive(:exit).with(1) - @knife.ui.should_receive(:error).with("No help found for 'chickens'") - @knife.ui.should_receive(:msg).with(/knife/) + allow(@knife.ui).to receive(:error) + allow(@knife.ui).to receive(:info) + allow(@knife.ui).to receive(:msg) + expect(@knife).to receive(:exit).with(1) + expect(@knife.ui).to receive(:error).with("No help found for 'chickens'") + expect(@knife.ui).to receive(:msg).with(/knife/) @knife.find_manpages_for_query("chickens") end end describe "print_help_topics" do it "should print the known help topics" do - @knife.ui.stub(:msg) - @knife.ui.stub(:info) - @knife.ui.should_receive(:msg).with(/knife/) + allow(@knife.ui).to receive(:msg) + allow(@knife.ui).to receive(:info) + expect(@knife.ui).to receive(:msg).with(/knife/) @knife.print_help_topics end it "should shorten topics prefixed by knife-" do - @knife.ui.stub(:msg) - @knife.ui.stub(:info) - @knife.ui.should_receive(:msg).with(/node/) + allow(@knife.ui).to receive(:msg) + allow(@knife.ui).to receive(:info) + expect(@knife.ui).to receive(:msg).with(/node/) @knife.print_help_topics end it "should not leave topics prefixed by knife-" do - @knife.ui.stub(:msg) - @knife.ui.stub(:info) - @knife.ui.should_not_receive(:msg).with(/knife-node/) + allow(@knife.ui).to receive(:msg) + allow(@knife.ui).to receive(:info) + expect(@knife.ui).not_to receive(:msg).with(/knife-node/) @knife.print_help_topics end end diff --git a/spec/unit/knife/node_bulk_delete_spec.rb b/spec/unit/knife/node_bulk_delete_spec.rb index 3faece5469..57a8d0bf64 100644 --- a/spec/unit/knife/node_bulk_delete_spec.rb +++ b/spec/unit/knife/node_bulk_delete_spec.rb @@ -26,8 +26,8 @@ describe Chef::Knife::NodeBulkDelete do @knife = Chef::Knife::NodeBulkDelete.new @knife.name_args = ["."] @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) - @knife.ui.stub(:confirm).and_return(true) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:confirm).and_return(true) @nodes = Hash.new %w{adam brent jacob}.each do |node_name| @nodes[node_name] = "http://localhost:4000/nodes/#{node_name}" @@ -40,11 +40,11 @@ describe Chef::Knife::NodeBulkDelete do inflatedish[name] = Chef::Node.new.tap {|n| n.name(name)} inflatedish end - Chef::Node.should_receive(:list).and_return(@nodes) + expect(Chef::Node).to receive(:list).and_return(@nodes) # I hate not having == defined for anything :( actual = @knife.all_nodes - actual.keys.should =~ expected.keys - actual.values.map {|n| n.name }.should =~ %w[adam brent jacob] + expect(actual.keys).to match_array(expected.keys) + expect(actual.values.map {|n| n.name }).to match_array(%w[adam brent jacob]) end end @@ -53,41 +53,41 @@ describe Chef::Knife::NodeBulkDelete do @inflatedish_list = @nodes.keys.inject({}) do |nodes_by_name, name| node = Chef::Node.new() node.name(name) - node.stub(:destroy).and_return(true) + allow(node).to receive(:destroy).and_return(true) nodes_by_name[name] = node nodes_by_name end - @knife.stub(:all_nodes).and_return(@inflatedish_list) + allow(@knife).to receive(:all_nodes).and_return(@inflatedish_list) end it "should print the nodes you are about to delete" do @knife.run - @stdout.string.should match(/#{@knife.ui.list(@nodes.keys.sort, :columns_down)}/) + expect(@stdout.string).to match(/#{@knife.ui.list(@nodes.keys.sort, :columns_down)}/) end it "should confirm you really want to delete them" do - @knife.ui.should_receive(:confirm) + expect(@knife.ui).to receive(:confirm) @knife.run end it "should delete each node" do @inflatedish_list.each_value do |n| - n.should_receive(:destroy) + expect(n).to receive(:destroy) end @knife.run end it "should only delete nodes that match the regex" do @knife.name_args = ['adam'] - @inflatedish_list['adam'].should_receive(:destroy) - @inflatedish_list['brent'].should_not_receive(:destroy) - @inflatedish_list['jacob'].should_not_receive(:destroy) + expect(@inflatedish_list['adam']).to receive(:destroy) + expect(@inflatedish_list['brent']).not_to receive(:destroy) + expect(@inflatedish_list['jacob']).not_to receive(:destroy) @knife.run end it "should exit if the regex is not provided" do @knife.name_args = [] - lambda { @knife.run }.should raise_error(SystemExit) + expect { @knife.run }.to raise_error(SystemExit) end end diff --git a/spec/unit/knife/node_delete_spec.rb b/spec/unit/knife/node_delete_spec.rb index 04eca389c6..0941d850e5 100644 --- a/spec/unit/knife/node_delete_spec.rb +++ b/spec/unit/knife/node_delete_spec.rb @@ -26,41 +26,41 @@ describe Chef::Knife::NodeDelete do :print_after => nil } @knife.name_args = [ "adam" ] - @knife.stub(:output).and_return(true) - @knife.stub(:confirm).and_return(true) + allow(@knife).to receive(:output).and_return(true) + allow(@knife).to receive(:confirm).and_return(true) @node = Chef::Node.new() - @node.stub(:destroy).and_return(true) - Chef::Node.stub(:load).and_return(@node) + allow(@node).to receive(:destroy).and_return(true) + allow(Chef::Node).to receive(:load).and_return(@node) @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe "run" do it "should confirm that you want to delete" do - @knife.should_receive(:confirm) + expect(@knife).to receive(:confirm) @knife.run end it "should load the node" do - Chef::Node.should_receive(:load).with("adam").and_return(@node) + expect(Chef::Node).to receive(:load).with("adam").and_return(@node) @knife.run end it "should delete the node" do - @node.should_receive(:destroy).and_return(@node) + expect(@node).to receive(:destroy).and_return(@node) @knife.run end it "should not print the node" do - @knife.should_not_receive(:output).with("poop") + expect(@knife).not_to receive(:output).with("poop") @knife.run end describe "with -p or --print-after" do it "should pretty print the node, formatted for display" do @knife.config[:print_after] = true - @knife.should_receive(:format_for_display).with(@node).and_return("poop") - @knife.should_receive(:output).with("poop") + expect(@knife).to receive(:format_for_display).with(@node).and_return("poop") + expect(@knife).to receive(:output).with("poop") @knife.run end end diff --git a/spec/unit/knife/node_edit_spec.rb b/spec/unit/knife/node_edit_spec.rb index 27db3416f4..58e2da2a1c 100644 --- a/spec/unit/knife/node_edit_spec.rb +++ b/spec/unit/knife/node_edit_spec.rb @@ -39,13 +39,13 @@ describe Chef::Knife::NodeEdit do end it "should load the node" do - Chef::Node.should_receive(:load).with("adam").and_return(@node) + expect(Chef::Node).to receive(:load).with("adam").and_return(@node) @knife.node end describe "after loading the node" do before do - @knife.stub(:node).and_return(@node) + allow(@knife).to receive(:node).and_return(@node) @node.automatic_attrs = {:go => :away} @node.default_attrs = {:hide => :me} @node.override_attrs = {:dont => :show} @@ -56,37 +56,37 @@ describe Chef::Knife::NodeEdit do it "creates a view of the node without attributes from roles or ohai" do actual = deserialized_json_view - actual.should_not have_key("automatic") - actual.should_not have_key("override") - actual.should_not have_key("default") - actual["normal"].should == {"do_show" => "these"} - actual["run_list"].should == ["recipe[foo]"] - actual["chef_environment"].should == "prod" + expect(actual).not_to have_key("automatic") + expect(actual).not_to have_key("override") + expect(actual).not_to have_key("default") + expect(actual["normal"]).to eq({"do_show" => "these"}) + expect(actual["run_list"]).to eq(["recipe[foo]"]) + expect(actual["chef_environment"]).to eq("prod") end it "shows the extra attributes when given the --all option" do @knife.config[:all_attributes] = true actual = deserialized_json_view - actual["automatic"].should == {"go" => "away"} - actual["override"].should == {"dont" => "show"} - actual["default"].should == {"hide" => "me"} - actual["normal"].should == {"do_show" => "these"} - actual["run_list"].should == ["recipe[foo]"] - actual["chef_environment"].should == "prod" + expect(actual["automatic"]).to eq({"go" => "away"}) + expect(actual["override"]).to eq({"dont" => "show"}) + expect(actual["default"]).to eq({"hide" => "me"}) + expect(actual["normal"]).to eq({"do_show" => "these"}) + expect(actual["run_list"]).to eq(["recipe[foo]"]) + expect(actual["chef_environment"]).to eq("prod") end it "does not consider unedited data updated" do view = deserialized_json_view @knife.node_editor.send(:apply_updates, view) - @knife.node_editor.should_not be_updated + expect(@knife.node_editor).not_to be_updated end it "considers edited data updated" do view = deserialized_json_view view["run_list"] << "role[fuuu]" @knife.node_editor.send(:apply_updates, view) - @knife.node_editor.should be_updated + expect(@knife.node_editor).to be_updated end end @@ -94,7 +94,7 @@ describe Chef::Knife::NodeEdit do describe "edit_node" do before do - @knife.stub(:node).and_return(@node) + allow(@knife).to receive(:node).and_return(@node) end let(:subject) { @knife.node_editor.edit_node } diff --git a/spec/unit/knife/node_environment_set_spec.rb b/spec/unit/knife/node_environment_set_spec.rb index 46ee1fea18..10267915d7 100644 --- a/spec/unit/knife/node_environment_set_spec.rb +++ b/spec/unit/knife/node_environment_set_spec.rb @@ -23,32 +23,32 @@ describe Chef::Knife::NodeEnvironmentSet do Chef::Config[:node_name] = "webmonkey.example.com" @knife = Chef::Knife::NodeEnvironmentSet.new @knife.name_args = [ "adam", "bar" ] - @knife.stub(:output).and_return(true) + allow(@knife).to receive(:output).and_return(true) @node = Chef::Node.new() @node.name("knifetest-node") @node.chef_environment << "foo" - @node.stub(:save).and_return(true) - Chef::Node.stub(:load).and_return(@node) + allow(@node).to receive(:save).and_return(true) + allow(Chef::Node).to receive(:load).and_return(@node) end describe "run" do it "should load the node" do - Chef::Node.should_receive(:load).with("adam") + expect(Chef::Node).to receive(:load).with("adam") @knife.run end it "should update the environment" do @knife.run - @node.chef_environment.should == 'bar' + expect(@node.chef_environment).to eq('bar') end it "should save the node" do - @node.should_receive(:save) + expect(@node).to receive(:save) @knife.run end it "should print the environment" do - @knife.should_receive(:output).and_return(true) + expect(@knife).to receive(:output).and_return(true) @knife.run end @@ -58,13 +58,13 @@ describe Chef::Knife::NodeEnvironmentSet do @stdout = StringIO.new @stderr = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) - @knife.ui.stub(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) end it "should exit" do @knife.name_args = [ "adam" ] - lambda { @knife.run }.should raise_error SystemExit + expect { @knife.run }.to raise_error SystemExit end it "should show the user the usage and an error" do @@ -72,8 +72,8 @@ describe Chef::Knife::NodeEnvironmentSet do begin ; @knife.run ; rescue SystemExit ; end - @stdout.string.should eq "USAGE: knife node environment set NODE ENVIRONMENT\n" - @stderr.string.should eq "FATAL: You must specify a node name and an environment.\n" + expect(@stdout.string).to eq "USAGE: knife node environment set NODE ENVIRONMENT\n" + expect(@stderr.string).to eq "FATAL: You must specify a node name and an environment.\n" end end end diff --git a/spec/unit/knife/node_from_file_spec.rb b/spec/unit/knife/node_from_file_spec.rb index 56a2a08b68..623904753e 100644 --- a/spec/unit/knife/node_from_file_spec.rb +++ b/spec/unit/knife/node_from_file_spec.rb @@ -28,30 +28,30 @@ describe Chef::Knife::NodeFromFile do :print_after => nil } @knife.name_args = [ "adam.rb" ] - @knife.stub(:output).and_return(true) - @knife.stub(:confirm).and_return(true) + allow(@knife).to receive(:output).and_return(true) + allow(@knife).to receive(:confirm).and_return(true) @node = Chef::Node.new() - @node.stub(:save) - @knife.loader.stub(:load_from).and_return(@node) + allow(@node).to receive(:save) + allow(@knife.loader).to receive(:load_from).and_return(@node) @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe "run" do it "should load from a file" do - @knife.loader.should_receive(:load_from).with('nodes', 'adam.rb').and_return(@node) + expect(@knife.loader).to receive(:load_from).with('nodes', 'adam.rb').and_return(@node) @knife.run end it "should not print the Node" do - @knife.should_not_receive(:output) + expect(@knife).not_to receive(:output) @knife.run end describe "with -p or --print-after" do it "should print the Node" do @knife.config[:print_after] = true - @knife.should_receive(:output) + expect(@knife).to receive(:output) @knife.run end end diff --git a/spec/unit/knife/node_list_spec.rb b/spec/unit/knife/node_list_spec.rb index cad2d6482d..71edea78f7 100644 --- a/spec/unit/knife/node_list_spec.rb +++ b/spec/unit/knife/node_list_spec.rb @@ -23,38 +23,38 @@ describe Chef::Knife::NodeList do Chef::Config[:node_name] = "webmonkey.example.com" Chef::Config[:environment] = nil # reset this value each time, as it is not reloaded @knife = Chef::Knife::NodeList.new - @knife.stub(:output).and_return(true) + allow(@knife).to receive(:output).and_return(true) @list = { "foo" => "http://example.com/foo", "bar" => "http://example.com/foo" } - Chef::Node.stub(:list).and_return(@list) - Chef::Node.stub(:list_by_environment).and_return(@list) + allow(Chef::Node).to receive(:list).and_return(@list) + allow(Chef::Node).to receive(:list_by_environment).and_return(@list) end describe "run" do it "should list all of the nodes if -E is not specified" do - Chef::Node.should_receive(:list).and_return(@list) + expect(Chef::Node).to receive(:list).and_return(@list) @knife.run end it "should pretty print the list" do - Chef::Node.should_receive(:list).and_return(@list) - @knife.should_receive(:output).with([ "bar", "foo" ]) + expect(Chef::Node).to receive(:list).and_return(@list) + expect(@knife).to receive(:output).with([ "bar", "foo" ]) @knife.run end it "should list nodes in the specific environment if -E ENVIRONMENT is specified" do Chef::Config[:environment] = "prod" - Chef::Node.should_receive(:list_by_environment).with("prod").and_return(@list) + expect(Chef::Node).to receive(:list_by_environment).with("prod").and_return(@list) @knife.run end describe "with -w or --with-uri" do it "should pretty print the hash" do @knife.config[:with_uri] = true - Chef::Node.should_receive(:list).and_return(@list) - @knife.should_receive(:output).with(@list) + expect(Chef::Node).to receive(:list).and_return(@list) + expect(@knife).to receive(:output).with(@list) @knife.run end end diff --git a/spec/unit/knife/node_run_list_add_spec.rb b/spec/unit/knife/node_run_list_add_spec.rb index bd33a359a2..92fbfd23fe 100644 --- a/spec/unit/knife/node_run_list_add_spec.rb +++ b/spec/unit/knife/node_run_list_add_spec.rb @@ -26,30 +26,30 @@ describe Chef::Knife::NodeRunListAdd do :after => nil } @knife.name_args = [ "adam", "role[monkey]" ] - @knife.stub(:output).and_return(true) + allow(@knife).to receive(:output).and_return(true) @node = Chef::Node.new() - @node.stub(:save).and_return(true) - Chef::Node.stub(:load).and_return(@node) + allow(@node).to receive(:save).and_return(true) + allow(Chef::Node).to receive(:load).and_return(@node) end describe "run" do it "should load the node" do - Chef::Node.should_receive(:load).with("adam") + expect(Chef::Node).to receive(:load).with("adam") @knife.run end it "should add to the run list" do @knife.run - @node.run_list[0].should == 'role[monkey]' + expect(@node.run_list[0]).to eq('role[monkey]') end it "should save the node" do - @node.should_receive(:save) + expect(@node).to receive(:save) @knife.run end it "should print the run list" do - @knife.should_receive(:output).and_return(true) + expect(@knife).to receive(:output).and_return(true) @knife.run end @@ -59,9 +59,9 @@ describe Chef::Knife::NodeRunListAdd do @node.run_list << "role[barn]" @knife.config[:after] = "role[acorns]" @knife.run - @node.run_list[0].should == "role[acorns]" - @node.run_list[1].should == "role[monkey]" - @node.run_list[2].should == "role[barn]" + expect(@node.run_list[0]).to eq("role[acorns]") + expect(@node.run_list[1]).to eq("role[monkey]") + expect(@node.run_list[2]).to eq("role[barn]") end end @@ -71,9 +71,9 @@ describe Chef::Knife::NodeRunListAdd do @node.run_list << "role[barn]" @knife.config[:before] = "role[acorns]" @knife.run - @node.run_list[0].should == "role[monkey]" - @node.run_list[1].should == "role[acorns]" - @node.run_list[2].should == "role[barn]" + expect(@node.run_list[0]).to eq("role[monkey]") + expect(@node.run_list[1]).to eq("role[acorns]") + expect(@node.run_list[2]).to eq("role[barn]") end end @@ -83,8 +83,8 @@ describe Chef::Knife::NodeRunListAdd do @node.run_list << "role[barn]" @knife.config[:before] = "role[acorns]" @knife.config[:after] = "role[acorns]" - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end end @@ -93,9 +93,9 @@ describe Chef::Knife::NodeRunListAdd do @knife.name_args = [ "adam", "role[monkey],role[duck]" ] @node.run_list << "role[acorns]" @knife.run - @node.run_list[0].should == "role[acorns]" - @node.run_list[1].should == "role[monkey]" - @node.run_list[2].should == "role[duck]" + expect(@node.run_list[0]).to eq("role[acorns]") + expect(@node.run_list[1]).to eq("role[monkey]") + expect(@node.run_list[2]).to eq("role[duck]") end end @@ -104,9 +104,9 @@ describe Chef::Knife::NodeRunListAdd do @knife.name_args = [ "adam", "role[monkey], role[duck]" ] @node.run_list << "role[acorns]" @knife.run - @node.run_list[0].should == "role[acorns]" - @node.run_list[1].should == "role[monkey]" - @node.run_list[2].should == "role[duck]" + expect(@node.run_list[0]).to eq("role[acorns]") + expect(@node.run_list[1]).to eq("role[monkey]") + expect(@node.run_list[2]).to eq("role[duck]") end end @@ -115,9 +115,9 @@ describe Chef::Knife::NodeRunListAdd do @knife.name_args = [ "adam", "role[monkey]", "role[duck]" ] @node.run_list << "role[acorns]" @knife.run - @node.run_list[0].should == "role[acorns]" - @node.run_list[1].should == "role[monkey]" - @node.run_list[2].should == "role[duck]" + expect(@node.run_list[0]).to eq("role[acorns]") + expect(@node.run_list[1]).to eq("role[monkey]") + expect(@node.run_list[2]).to eq("role[duck]") end end @@ -126,9 +126,9 @@ describe Chef::Knife::NodeRunListAdd do @knife.name_args = [ "adam", "role[monkey]", "role[duck],recipe[bird::fly]" ] @node.run_list << "role[acorns]" @knife.run - @node.run_list[0].should == "role[acorns]" - @node.run_list[1].should == "role[monkey]" - @node.run_list[2].should == "role[duck]" + expect(@node.run_list[0]).to eq("role[acorns]") + expect(@node.run_list[1]).to eq("role[monkey]") + expect(@node.run_list[2]).to eq("role[duck]") end end @@ -137,8 +137,8 @@ describe Chef::Knife::NodeRunListAdd do @knife.name_args = [ "adam", "role[monkey]," ] @node.run_list << "role[acorns]" @knife.run - @node.run_list[0].should == "role[acorns]" - @node.run_list[1].should == "role[monkey]" + expect(@node.run_list[0]).to eq("role[acorns]") + expect(@node.run_list[1]).to eq("role[monkey]") end end end diff --git a/spec/unit/knife/node_run_list_remove_spec.rb b/spec/unit/knife/node_run_list_remove_spec.rb index 5a008a3e07..ea951e21dd 100644 --- a/spec/unit/knife/node_run_list_remove_spec.rb +++ b/spec/unit/knife/node_run_list_remove_spec.rb @@ -27,33 +27,33 @@ describe Chef::Knife::NodeRunListRemove do @node = Chef::Node.new() @node.name("knifetest-node") @node.run_list << "role[monkey]" - @node.stub(:save).and_return(true) + allow(@node).to receive(:save).and_return(true) - @knife.ui.stub(:output).and_return(true) - @knife.ui.stub(:confirm).and_return(true) + allow(@knife.ui).to receive(:output).and_return(true) + allow(@knife.ui).to receive(:confirm).and_return(true) - Chef::Node.stub(:load).and_return(@node) + allow(Chef::Node).to receive(:load).and_return(@node) end describe "run" do it "should load the node" do - Chef::Node.should_receive(:load).with("adam").and_return(@node) + expect(Chef::Node).to receive(:load).with("adam").and_return(@node) @knife.run end it "should remove the item from the run list" do @knife.run - @node.run_list[0].should_not == 'role[monkey]' + expect(@node.run_list[0]).not_to eq('role[monkey]') end it "should save the node" do - @node.should_receive(:save).and_return(true) + expect(@node).to receive(:save).and_return(true) @knife.run end it "should print the run list" do @knife.config[:print_after] = true - @knife.ui.should_receive(:output).with({ "knifetest-node" => { 'run_list' => [] } }) + expect(@knife.ui).to receive(:output).with({ "knifetest-node" => { 'run_list' => [] } }) @knife.run end @@ -63,8 +63,8 @@ describe Chef::Knife::NodeRunListRemove do @node.run_list << 'recipe[duck::type]' @knife.name_args = [ 'adam', 'role[monkey],recipe[duck::type]' ] @knife.run - @node.run_list.should_not include('role[monkey]') - @node.run_list.should_not include('recipe[duck::type]') + expect(@node.run_list).not_to include('role[monkey]') + expect(@node.run_list).not_to include('recipe[duck::type]') end end end diff --git a/spec/unit/knife/node_run_list_set_spec.rb b/spec/unit/knife/node_run_list_set_spec.rb index 02281f8385..68daaafd70 100644 --- a/spec/unit/knife/node_run_list_set_spec.rb +++ b/spec/unit/knife/node_run_list_set_spec.rb @@ -24,30 +24,30 @@ describe Chef::Knife::NodeRunListSet do @knife = Chef::Knife::NodeRunListSet.new @knife.config = {} @knife.name_args = [ "adam", "role[monkey]" ] - @knife.stub(:output).and_return(true) + allow(@knife).to receive(:output).and_return(true) @node = Chef::Node.new() - @node.stub(:save).and_return(true) - Chef::Node.stub(:load).and_return(@node) + allow(@node).to receive(:save).and_return(true) + allow(Chef::Node).to receive(:load).and_return(@node) end describe "run" do it "should load the node" do - Chef::Node.should_receive(:load).with("adam") + expect(Chef::Node).to receive(:load).with("adam") @knife.run end it "should set the run list" do @knife.run - @node.run_list[0].should == 'role[monkey]' + expect(@node.run_list[0]).to eq('role[monkey]') end it "should save the node" do - @node.should_receive(:save) + expect(@node).to receive(:save) @knife.run end it "should print the run list" do - @knife.should_receive(:output).and_return(true) + expect(@knife).to receive(:output).and_return(true) @knife.run end @@ -55,8 +55,8 @@ describe Chef::Knife::NodeRunListSet do it "should set the run list to all the entries" do @knife.name_args = [ "adam", "role[monkey],role[duck]" ] @knife.run - @node.run_list[0].should == "role[monkey]" - @node.run_list[1].should == "role[duck]" + expect(@node.run_list[0]).to eq("role[monkey]") + expect(@node.run_list[1]).to eq("role[duck]") end end @@ -64,8 +64,8 @@ describe Chef::Knife::NodeRunListSet do it "should set the run list to all the entries" do @knife.name_args = [ "adam", "role[monkey], role[duck]" ] @knife.run - @node.run_list[0].should == "role[monkey]" - @node.run_list[1].should == "role[duck]" + expect(@node.run_list[0]).to eq("role[monkey]") + expect(@node.run_list[1]).to eq("role[duck]") end end @@ -73,8 +73,8 @@ describe Chef::Knife::NodeRunListSet do it "should set the run list to all the entries" do @knife.name_args = [ "adam", "role[monkey]", "role[duck]" ] @knife.run - @node.run_list[0].should == "role[monkey]" - @node.run_list[1].should == "role[duck]" + expect(@node.run_list[0]).to eq("role[monkey]") + expect(@node.run_list[1]).to eq("role[duck]") end end @@ -82,8 +82,8 @@ describe Chef::Knife::NodeRunListSet do it "should add to the run list all the entries" do @knife.name_args = [ "adam", "role[monkey]", "role[duck],recipe[bird::fly]" ] @knife.run - @node.run_list[0].should == "role[monkey]" - @node.run_list[1].should == "role[duck]" + expect(@node.run_list[0]).to eq("role[monkey]") + expect(@node.run_list[1]).to eq("role[duck]") end end @@ -91,7 +91,7 @@ describe Chef::Knife::NodeRunListSet do it "should add to the run list one item" do @knife.name_args = [ "adam", "role[monkey]," ] @knife.run - @node.run_list[0].should == "role[monkey]" + expect(@node.run_list[0]).to eq("role[monkey]") end end @@ -99,15 +99,15 @@ describe Chef::Knife::NodeRunListSet do it "should overwrite any existing run list items" do @node.run_list << "role[acorns]" @node.run_list << "role[zebras]" - @node.run_list[0].should == "role[acorns]" - @node.run_list[1].should == "role[zebras]" - @node.run_list.run_list_items.size.should == 2 + expect(@node.run_list[0]).to eq("role[acorns]") + expect(@node.run_list[1]).to eq("role[zebras]") + expect(@node.run_list.run_list_items.size).to eq(2) @knife.name_args = [ "adam", "role[monkey]", "role[duck]" ] @knife.run - @node.run_list[0].should == "role[monkey]" - @node.run_list[1].should == "role[duck]" - @node.run_list.run_list_items.size.should == 2 + expect(@node.run_list[0]).to eq("role[monkey]") + expect(@node.run_list[1]).to eq("role[duck]") + expect(@node.run_list.run_list_items.size).to eq(2) end end @@ -117,13 +117,13 @@ describe Chef::Knife::NodeRunListSet do @stdout = StringIO.new @stderr = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) - @knife.ui.stub(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) end it "should exit" do @knife.name_args = [ "adam" ] - lambda { @knife.run }.should raise_error SystemExit + expect { @knife.run }.to raise_error SystemExit end it "should show the user" do @@ -131,8 +131,8 @@ describe Chef::Knife::NodeRunListSet do begin ; @knife.run ; rescue SystemExit ; end - @stdout.string.should eq "USAGE: knife node run_list set NODE ENTRIES (options)\n" - @stderr.string.should eq "FATAL: You must supply both a node name and a run list.\n" + expect(@stdout.string).to eq "USAGE: knife node run_list set NODE ENTRIES (options)\n" + expect(@stderr.string).to eq "FATAL: You must supply both a node name and a run list.\n" end end diff --git a/spec/unit/knife/role_bulk_delete_spec.rb b/spec/unit/knife/role_bulk_delete_spec.rb index eb1d3b4cff..5b79e52a04 100644 --- a/spec/unit/knife/role_bulk_delete_spec.rb +++ b/spec/unit/knife/role_bulk_delete_spec.rb @@ -27,53 +27,53 @@ describe Chef::Knife::RoleBulkDelete do } @knife.name_args = ["."] @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) - @knife.ui.stub(:confirm).and_return(true) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:confirm).and_return(true) @roles = Hash.new %w{dev staging production}.each do |role_name| role = Chef::Role.new() role.name(role_name) - role.stub(:destroy).and_return(true) + allow(role).to receive(:destroy).and_return(true) @roles[role_name] = role end - Chef::Role.stub(:list).and_return(@roles) + allow(Chef::Role).to receive(:list).and_return(@roles) end describe "run" do it "should get the list of the roles" do - Chef::Role.should_receive(:list).and_return(@roles) + expect(Chef::Role).to receive(:list).and_return(@roles) @knife.run end it "should print the roles you are about to delete" do @knife.run - @stdout.string.should match(/#{@knife.ui.list(@roles.keys.sort, :columns_down)}/) + expect(@stdout.string).to match(/#{@knife.ui.list(@roles.keys.sort, :columns_down)}/) end it "should confirm you really want to delete them" do - @knife.ui.should_receive(:confirm) + expect(@knife.ui).to receive(:confirm) @knife.run end it "should delete each role" do @roles.each_value do |r| - r.should_receive(:destroy) + expect(r).to receive(:destroy) end @knife.run end it "should only delete roles that match the regex" do @knife.name_args = ["dev"] - @roles["dev"].should_receive(:destroy) - @roles["staging"].should_not_receive(:destroy) - @roles["production"].should_not_receive(:destroy) + expect(@roles["dev"]).to receive(:destroy) + expect(@roles["staging"]).not_to receive(:destroy) + expect(@roles["production"]).not_to receive(:destroy) @knife.run end it "should exit if the regex is not provided" do @knife.name_args = [] - lambda { @knife.run }.should raise_error(SystemExit) + expect { @knife.run }.to raise_error(SystemExit) end end diff --git a/spec/unit/knife/role_create_spec.rb b/spec/unit/knife/role_create_spec.rb index a4d7392b68..fb748c51f6 100644 --- a/spec/unit/knife/role_create_spec.rb +++ b/spec/unit/knife/role_create_spec.rb @@ -26,45 +26,45 @@ describe Chef::Knife::RoleCreate do :description => nil } @knife.name_args = [ "adam" ] - @knife.stub(:output).and_return(true) + allow(@knife).to receive(:output).and_return(true) @role = Chef::Role.new() - @role.stub(:save) - Chef::Role.stub(:new).and_return(@role) - @knife.stub(:edit_data).and_return(@role) + allow(@role).to receive(:save) + allow(Chef::Role).to receive(:new).and_return(@role) + allow(@knife).to receive(:edit_data).and_return(@role) @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe "run" do it "should create a new role" do - Chef::Role.should_receive(:new).and_return(@role) + expect(Chef::Role).to receive(:new).and_return(@role) @knife.run end it "should set the role name" do - @role.should_receive(:name).with("adam") + expect(@role).to receive(:name).with("adam") @knife.run end it "should not print the role" do - @knife.should_not_receive(:output) + expect(@knife).not_to receive(:output) @knife.run end it "should allow you to edit the data" do - @knife.should_receive(:edit_data).with(@role) + expect(@knife).to receive(:edit_data).with(@role) @knife.run end it "should save the role" do - @role.should_receive(:save) + expect(@role).to receive(:save) @knife.run end describe "with -d or --description" do it "should set the description" do @knife.config[:description] = "All is bob" - @role.should_receive(:description).with("All is bob") + expect(@role).to receive(:description).with("All is bob") @knife.run end end @@ -72,7 +72,7 @@ describe Chef::Knife::RoleCreate do describe "with -p or --print-after" do it "should pretty print the node, formatted for display" do @knife.config[:print_after] = true - @knife.should_receive(:output).with(@role) + expect(@knife).to receive(:output).with(@role) @knife.run end end diff --git a/spec/unit/knife/role_delete_spec.rb b/spec/unit/knife/role_delete_spec.rb index 0771446d49..b1a0d90410 100644 --- a/spec/unit/knife/role_delete_spec.rb +++ b/spec/unit/knife/role_delete_spec.rb @@ -26,40 +26,40 @@ describe Chef::Knife::RoleDelete do :print_after => nil } @knife.name_args = [ "adam" ] - @knife.stub(:output).and_return(true) - @knife.stub(:confirm).and_return(true) + allow(@knife).to receive(:output).and_return(true) + allow(@knife).to receive(:confirm).and_return(true) @role = Chef::Role.new() - @role.stub(:destroy).and_return(true) - Chef::Role.stub(:load).and_return(@role) + allow(@role).to receive(:destroy).and_return(true) + allow(Chef::Role).to receive(:load).and_return(@role) @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe "run" do it "should confirm that you want to delete" do - @knife.should_receive(:confirm) + expect(@knife).to receive(:confirm) @knife.run end it "should load the Role" do - Chef::Role.should_receive(:load).with("adam").and_return(@role) + expect(Chef::Role).to receive(:load).with("adam").and_return(@role) @knife.run end it "should delete the Role" do - @role.should_receive(:destroy).and_return(@role) + expect(@role).to receive(:destroy).and_return(@role) @knife.run end it "should not print the Role" do - @knife.should_not_receive(:output) + expect(@knife).not_to receive(:output) @knife.run end describe "with -p or --print-after" do it "should pretty print the Role, formatted for display" do @knife.config[:print_after] = true - @knife.should_receive(:output) + expect(@knife).to receive(:output) @knife.run end end diff --git a/spec/unit/knife/role_edit_spec.rb b/spec/unit/knife/role_edit_spec.rb index f6d3b41d98..0975c6458d 100644 --- a/spec/unit/knife/role_edit_spec.rb +++ b/spec/unit/knife/role_edit_spec.rb @@ -24,22 +24,22 @@ describe Chef::Knife::RoleEdit do @knife = Chef::Knife::RoleEdit.new @knife.config[:print_after] = nil @knife.name_args = [ "adam" ] - @knife.ui.stub(:output).and_return(true) + allow(@knife.ui).to receive(:output).and_return(true) @role = Chef::Role.new() - @role.stub(:save) - Chef::Role.stub(:load).and_return(@role) - @knife.ui.stub(:edit_data).and_return(@role) - @knife.ui.stub(:msg) + allow(@role).to receive(:save) + allow(Chef::Role).to receive(:load).and_return(@role) + allow(@knife.ui).to receive(:edit_data).and_return(@role) + allow(@knife.ui).to receive(:msg) end describe "run" do it "should load the role" do - Chef::Role.should_receive(:load).with("adam").and_return(@role) + expect(Chef::Role).to receive(:load).with("adam").and_return(@role) @knife.run end it "should edit the role data" do - @knife.ui.should_receive(:edit_data).with(@role) + expect(@knife.ui).to receive(:edit_data).with(@role) @knife.run end @@ -47,29 +47,29 @@ describe Chef::Knife::RoleEdit do pansy = Chef::Role.new @role.name("new_role_name") - @knife.ui.should_receive(:edit_data).with(@role).and_return(pansy) - pansy.should_receive(:save) + expect(@knife.ui).to receive(:edit_data).with(@role).and_return(pansy) + expect(pansy).to receive(:save) @knife.run end it "should not save the unedited role data" do pansy = Chef::Role.new - @knife.ui.should_receive(:edit_data).with(@role).and_return(pansy) - pansy.should_not_receive(:save) + expect(@knife.ui).to receive(:edit_data).with(@role).and_return(pansy) + expect(pansy).not_to receive(:save) @knife.run end it "should not print the role" do - @knife.ui.should_not_receive(:output) + expect(@knife.ui).not_to receive(:output) @knife.run end describe "with -p or --print-after" do it "should pretty print the role, formatted for display" do @knife.config[:print_after] = true - @knife.ui.should_receive(:output).with(@role) + expect(@knife.ui).to receive(:output).with(@role) @knife.run end end diff --git a/spec/unit/knife/role_from_file_spec.rb b/spec/unit/knife/role_from_file_spec.rb index 986414647c..9379f08de3 100644 --- a/spec/unit/knife/role_from_file_spec.rb +++ b/spec/unit/knife/role_from_file_spec.rb @@ -28,30 +28,30 @@ describe Chef::Knife::RoleFromFile do :print_after => nil } @knife.name_args = [ "adam.rb" ] - @knife.stub(:output).and_return(true) - @knife.stub(:confirm).and_return(true) + allow(@knife).to receive(:output).and_return(true) + allow(@knife).to receive(:confirm).and_return(true) @role = Chef::Role.new() - @role.stub(:save) - @knife.loader.stub(:load_from).and_return(@role) + allow(@role).to receive(:save) + allow(@knife.loader).to receive(:load_from).and_return(@role) @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe "run" do it "should load from a file" do - @knife.loader.should_receive(:load_from).with('roles', 'adam.rb').and_return(@role) + expect(@knife.loader).to receive(:load_from).with('roles', 'adam.rb').and_return(@role) @knife.run end it "should not print the role" do - @knife.should_not_receive(:output) + expect(@knife).not_to receive(:output) @knife.run end describe "with -p or --print-after" do it "should print the role" do @knife.config[:print_after] = true - @knife.should_receive(:output) + expect(@knife).to receive(:output) @knife.run end end @@ -60,8 +60,8 @@ describe Chef::Knife::RoleFromFile do describe "run with multiple arguments" do it "should load each file" do @knife.name_args = [ "adam.rb", "caleb.rb" ] - @knife.loader.should_receive(:load_from).with('roles', 'adam.rb').and_return(@role) - @knife.loader.should_receive(:load_from).with('roles', 'caleb.rb').and_return(@role) + expect(@knife.loader).to receive(:load_from).with('roles', 'adam.rb').and_return(@role) + expect(@knife.loader).to receive(:load_from).with('roles', 'caleb.rb').and_return(@role) @knife.run end end diff --git a/spec/unit/knife/role_list_spec.rb b/spec/unit/knife/role_list_spec.rb index ef9642c04c..808a04d204 100644 --- a/spec/unit/knife/role_list_spec.rb +++ b/spec/unit/knife/role_list_spec.rb @@ -22,31 +22,31 @@ describe Chef::Knife::RoleList do before(:each) do Chef::Config[:node_name] = "webmonkey.example.com" @knife = Chef::Knife::RoleList.new - @knife.stub(:output).and_return(true) + allow(@knife).to receive(:output).and_return(true) @list = { "foo" => "http://example.com/foo", "bar" => "http://example.com/foo" } - Chef::Role.stub(:list).and_return(@list) + allow(Chef::Role).to receive(:list).and_return(@list) end describe "run" do it "should list the roles" do - Chef::Role.should_receive(:list).and_return(@list) + expect(Chef::Role).to receive(:list).and_return(@list) @knife.run end it "should pretty print the list" do - Chef::Role.should_receive(:list).and_return(@list) - @knife.should_receive(:output).with([ "bar", "foo" ]) + expect(Chef::Role).to receive(:list).and_return(@list) + expect(@knife).to receive(:output).with([ "bar", "foo" ]) @knife.run end describe "with -w or --with-uri" do it "should pretty print the hash" do @knife.config[:with_uri] = true - Chef::Role.should_receive(:list).and_return(@list) - @knife.should_receive(:output).with(@list) + expect(Chef::Role).to receive(:list).and_return(@list) + expect(@knife).to receive(:output).with(@list) @knife.run end end diff --git a/spec/unit/knife/ssh_spec.rb b/spec/unit/knife/ssh_spec.rb index 10d63c9c74..501b02c933 100644 --- a/spec/unit/knife/ssh_spec.rb +++ b/spec/unit/knife/ssh_spec.rb @@ -45,8 +45,8 @@ describe Chef::Knife::Ssh do end def configure_query(node_array) - @query.stub(:search).and_return([node_array]) - Chef::Search::Query.stub(:new).and_return(@query) + allow(@query).to receive(:search).and_return([node_array]) + allow(Chef::Search::Query).to receive(:new).and_return(@query) end def self.should_return_specified_attributes @@ -54,7 +54,7 @@ describe Chef::Knife::Ssh do @knife.config[:attribute] = "ipaddress" @knife.config[:attribute_from_cli] = "ipaddress" configure_query([@node_foo, @node_bar]) - @knife.should_receive(:session_from_list).with([['10.0.0.1', nil], ['10.0.0.2', nil]]) + expect(@knife).to receive(:session_from_list).with([['10.0.0.1', nil], ['10.0.0.2', nil]]) @knife.configure_session end @@ -62,14 +62,14 @@ describe Chef::Knife::Ssh do @knife.config[:attribute] = "config_file" # this value will be the config file @knife.config[:attribute_from_cli] = "ipaddress" # this is the value of the command line via #configure_attribute configure_query([@node_foo, @node_bar]) - @knife.should_receive(:session_from_list).with([['10.0.0.1', nil], ['10.0.0.2', nil]]) + expect(@knife).to receive(:session_from_list).with([['10.0.0.1', nil], ['10.0.0.2', nil]]) @knife.configure_session end end it "searchs for and returns an array of fqdns" do configure_query([@node_foo, @node_bar]) - @knife.should_receive(:session_from_list).with([ + expect(@knife).to receive(:session_from_list).with([ ['foo.example.org', nil], ['bar.example.org', nil] ]) @@ -86,7 +86,7 @@ describe Chef::Knife::Ssh do it "returns an array of cloud public hostnames" do configure_query([@node_foo, @node_bar]) - @knife.should_receive(:session_from_list).with([ + expect(@knife).to receive(:session_from_list).with([ ['ec2-10-0-0-1.compute-1.amazonaws.com', nil], ['ec2-10-0-0-2.compute-1.amazonaws.com', nil] ]) @@ -98,22 +98,22 @@ describe Chef::Knife::Ssh do it "should raise an error if no host are found" do configure_query([ ]) - @knife.ui.should_receive(:fatal) - @knife.should_receive(:exit).with(10) + expect(@knife.ui).to receive(:fatal) + expect(@knife).to receive(:exit).with(10) @knife.configure_session end context "when there are some hosts found but they do not have an attribute to connect with" do before do - @query.stub(:search).and_return([[@node_foo, @node_bar]]) + allow(@query).to receive(:search).and_return([[@node_foo, @node_bar]]) @node_foo.automatic_attrs[:fqdn] = nil @node_bar.automatic_attrs[:fqdn] = nil - Chef::Search::Query.stub(:new).and_return(@query) + allow(Chef::Search::Query).to receive(:new).and_return(@query) end it "should raise a specific error (CHEF-3402)" do - @knife.ui.should_receive(:fatal).with(/^2 nodes found/) - @knife.should_receive(:exit).with(10) + expect(@knife.ui).to receive(:fatal).with(/^2 nodes found/) + expect(@knife).to receive(:exit).with(10) @knife.configure_session end end @@ -126,7 +126,7 @@ describe Chef::Knife::Ssh do it "returns an array of provided values" do @knife.instance_variable_set(:@name_args, ["foo.example.org bar.example.org"]) - @knife.should_receive(:session_from_list).with(['foo.example.org', 'bar.example.org']) + expect(@knife).to receive(:session_from_list).with(['foo.example.org', 'bar.example.org']) @knife.configure_session end end @@ -140,34 +140,34 @@ describe Chef::Knife::Ssh do it "should return fqdn by default" do @knife.configure_attribute - @knife.config[:attribute].should == "fqdn" + expect(@knife.config[:attribute]).to eq("fqdn") end it "should return the value set in the configuration file" do Chef::Config[:knife][:ssh_attribute] = "config_file" @knife.configure_attribute - @knife.config[:attribute].should == "config_file" + expect(@knife.config[:attribute]).to eq("config_file") end it "should return the value set on the command line" do @knife.config[:attribute] = "command_line" @knife.configure_attribute - @knife.config[:attribute].should == "command_line" + expect(@knife.config[:attribute]).to eq("command_line") end it "should set attribute_from_cli to the value of attribute from the command line" do @knife.config[:attribute] = "command_line" @knife.configure_attribute - @knife.config[:attribute].should == "command_line" - @knife.config[:attribute_from_cli].should == "command_line" + expect(@knife.config[:attribute]).to eq("command_line") + expect(@knife.config[:attribute_from_cli]).to eq("command_line") end it "should prefer the command line over the config file for the value of attribute_from_cli" do Chef::Config[:knife][:ssh_attribute] = "config_file" @knife.config[:attribute] = "command_line" @knife.configure_attribute - @knife.config[:attribute].should == "command_line" - @knife.config[:attribute_from_cli].should == "command_line" + expect(@knife.config[:attribute]).to eq("command_line") + expect(@knife.config[:attribute_from_cli]).to eq("command_line") end end @@ -175,22 +175,22 @@ describe Chef::Knife::Ssh do before :each do @knife.instance_variable_set(:@longest, 0) ssh_config = {:timeout => 50, :user => "locutus", :port => 23 } - Net::SSH.stub(:configuration_for).with('the.b.org').and_return(ssh_config) + allow(Net::SSH).to receive(:configuration_for).with('the.b.org').and_return(ssh_config) end it "uses the port from an ssh config file" do @knife.session_from_list([['the.b.org', nil]]) - @knife.session.servers[0].port.should == 23 + expect(@knife.session.servers[0].port).to eq(23) end it "uses the port from a cloud attr" do @knife.session_from_list([['the.b.org', 123]]) - @knife.session.servers[0].port.should == 123 + expect(@knife.session.servers[0].port).to eq(123) end it "uses the user from an ssh config file" do @knife.session_from_list([['the.b.org', 123]]) - @knife.session.servers[0].user.should == "locutus" + expect(@knife.session.servers[0].user).to eq("locutus") end end @@ -206,26 +206,26 @@ describe Chef::Knife::Ssh do let(:command) { "false" } before do - execution_channel. - should_receive(:on_request). + expect(execution_channel). + to receive(:on_request). and_yield(nil, double(:data_stream, :read_long => exit_status)) - session_channel. - should_receive(:exec). + expect(session_channel). + to receive(:exec). with(command). and_yield(execution_channel, true) - execution_channel2. - should_receive(:on_request). + expect(execution_channel2). + to receive(:on_request). and_yield(nil, double(:data_stream, :read_long => exit_status2)) - session_channel2. - should_receive(:exec). + expect(session_channel2). + to receive(:exec). with(command). and_yield(execution_channel2, true) - session. - should_receive(:open_channel). + expect(session). + to receive(:open_channel). and_yield(session_channel). and_yield(session_channel2) end @@ -235,7 +235,7 @@ describe Chef::Knife::Ssh do let(:exit_status2) { 0 } it "returns a 0 exit code" do - @knife.ssh_command(command, session).should == 0 + expect(@knife.ssh_command(command, session)).to eq(0) end end @@ -244,7 +244,7 @@ describe Chef::Knife::Ssh do let(:exit_status2) { 0 } it "returns a non-zero exit code" do - @knife.ssh_command(command, session).should == 1 + expect(@knife.ssh_command(command, session)).to eq(1) end end @@ -253,7 +253,7 @@ describe Chef::Knife::Ssh do let(:exit_status2) { 2 } it "returns a non-zero exit code" do - @knife.ssh_command(command, session).should == 2 + expect(@knife.ssh_command(command, session)).to eq(2) end end end @@ -261,9 +261,9 @@ describe Chef::Knife::Ssh do describe "#run" do before do @query = Chef::Search::Query.new - @query.should_receive(:search).and_return([[@node_foo]]) - Chef::Search::Query.stub(:new).and_return(@query) - @knife.stub(:ssh_command).and_return(exit_code) + expect(@query).to receive(:search).and_return([[@node_foo]]) + allow(Chef::Search::Query).to receive(:new).and_return(@query) + allow(@knife).to receive(:ssh_command).and_return(exit_code) @knife.name_args = ['*:*', 'false'] end @@ -271,7 +271,7 @@ describe Chef::Knife::Ssh do let(:exit_code) { 1 } it "should exit with a non-zero exit code" do - @knife.should_receive(:exit).with(exit_code) + expect(@knife).to receive(:exit).with(exit_code) @knife.run end end @@ -280,7 +280,7 @@ describe Chef::Knife::Ssh do let(:exit_code) { 0 } it "should not exit" do - @knife.should_not_receive(:exit) + expect(@knife).not_to receive(:exit) @knife.run end end @@ -296,23 +296,23 @@ describe Chef::Knife::Ssh do # in this case ssh_password_ng exists, but ssh_password does not it "should prompt for a password when ssh_passsword_ng is nil" do @knife.config[:ssh_password_ng] = nil - @knife.should_receive(:get_password).and_return("mysekretpassw0rd") + expect(@knife).to receive(:get_password).and_return("mysekretpassw0rd") @knife.configure_password - @knife.config[:ssh_password].should == "mysekretpassw0rd" + expect(@knife.config[:ssh_password]).to eq("mysekretpassw0rd") end it "should set ssh_password to false if ssh_password_ng is false" do @knife.config[:ssh_password_ng] = false - @knife.should_not_receive(:get_password) + expect(@knife).not_to receive(:get_password) @knife.configure_password - @knife.config[:ssh_password].should be_false + expect(@knife.config[:ssh_password]).to be_falsey end it "should set ssh_password to ssh_password_ng if we set a password" do @knife.config[:ssh_password_ng] = "mysekretpassw0rd" - @knife.should_not_receive(:get_password) + expect(@knife).not_to receive(:get_password) @knife.configure_password - @knife.config[:ssh_password].should == "mysekretpassw0rd" + expect(@knife.config[:ssh_password]).to eq("mysekretpassw0rd") end end @@ -320,23 +320,23 @@ describe Chef::Knife::Ssh do # in this case ssh_password exists, but ssh_password_ng does not it "should set ssh_password to nil when ssh_password is nil" do @knife.config[:ssh_password] = nil - @knife.should_not_receive(:get_password) + expect(@knife).not_to receive(:get_password) @knife.configure_password - @knife.config[:ssh_password].should be_nil + expect(@knife.config[:ssh_password]).to be_nil end it "should set ssh_password to false when ssh_password is false" do @knife.config[:ssh_password] = false - @knife.should_not_receive(:get_password) + expect(@knife).not_to receive(:get_password) @knife.configure_password - @knife.config[:ssh_password].should be_false + expect(@knife.config[:ssh_password]).to be_falsey end it "should set ssh_password to ssh_password if we set a password" do @knife.config[:ssh_password] = "mysekretpassw0rd" - @knife.should_not_receive(:get_password) + expect(@knife).not_to receive(:get_password) @knife.configure_password - @knife.config[:ssh_password].should == "mysekretpassw0rd" + expect(@knife.config[:ssh_password]).to eq("mysekretpassw0rd") end end context "when setting ssh_password in the config variable" do @@ -347,23 +347,23 @@ describe Chef::Knife::Ssh do # in this case ssh_password_ng exists, but ssh_password does not it "should prompt for a password when ssh_passsword_ng is nil" do @knife.config[:ssh_password_ng] = nil - @knife.should_receive(:get_password).and_return("mysekretpassw0rd") + expect(@knife).to receive(:get_password).and_return("mysekretpassw0rd") @knife.configure_password - @knife.config[:ssh_password].should == "mysekretpassw0rd" + expect(@knife.config[:ssh_password]).to eq("mysekretpassw0rd") end it "should set ssh_password to the configured knife.rb value if ssh_password_ng is false" do @knife.config[:ssh_password_ng] = false - @knife.should_not_receive(:get_password) + expect(@knife).not_to receive(:get_password) @knife.configure_password - @knife.config[:ssh_password].should == "my_knife_passw0rd" + expect(@knife.config[:ssh_password]).to eq("my_knife_passw0rd") end it "should set ssh_password to ssh_password_ng if we set a password" do @knife.config[:ssh_password_ng] = "mysekretpassw0rd" - @knife.should_not_receive(:get_password) + expect(@knife).not_to receive(:get_password) @knife.configure_password - @knife.config[:ssh_password].should == "mysekretpassw0rd" + expect(@knife.config[:ssh_password]).to eq("mysekretpassw0rd") end end @@ -371,23 +371,23 @@ describe Chef::Knife::Ssh do # in this case ssh_password exists, but ssh_password_ng does not it "should set ssh_password to the configured knife.rb value when ssh_password is nil" do @knife.config[:ssh_password] = nil - @knife.should_not_receive(:get_password) + expect(@knife).not_to receive(:get_password) @knife.configure_password - @knife.config[:ssh_password].should == "my_knife_passw0rd" + expect(@knife.config[:ssh_password]).to eq("my_knife_passw0rd") end it "should set ssh_password to the configured knife.rb value when ssh_password is false" do @knife.config[:ssh_password] = false - @knife.should_not_receive(:get_password) + expect(@knife).not_to receive(:get_password) @knife.configure_password - @knife.config[:ssh_password].should == "my_knife_passw0rd" + expect(@knife.config[:ssh_password]).to eq("my_knife_passw0rd") end it "should set ssh_password to ssh_password if we set a password" do @knife.config[:ssh_password] = "mysekretpassw0rd" - @knife.should_not_receive(:get_password) + expect(@knife).not_to receive(:get_password) @knife.configure_password - @knife.config[:ssh_password].should == "mysekretpassw0rd" + expect(@knife.config[:ssh_password]).to eq("mysekretpassw0rd") end end end diff --git a/spec/unit/knife/ssl_check_spec.rb b/spec/unit/knife/ssl_check_spec.rb index bb803ce2ca..8eda555108 100644 --- a/spec/unit/knife/ssl_check_spec.rb +++ b/spec/unit/knife/ssl_check_spec.rb @@ -35,8 +35,8 @@ describe Chef::Knife::SslCheck do subject(:ssl_check) do s = Chef::Knife::SslCheck.new - s.ui.stub(:stdout).and_return(stdout_io) - s.ui.stub(:stderr).and_return(stderr_io) + allow(s.ui).to receive(:stdout).and_return(stdout_io) + allow(s.ui).to receive(:stderr).and_return(stderr_io) s.name_args = name_args s end @@ -106,17 +106,17 @@ E before do Chef::Config[:trusted_certs_dir] = trusted_certs_dir - ssl_check.stub(:trusted_certificates).and_return([trusted_cert_file]) - store.stub(:add_cert).with(certificate) - OpenSSL::X509::Store.stub(:new).and_return(store) - OpenSSL::X509::Certificate.stub(:new).with(IO.read(trusted_cert_file)).and_return(certificate) - ssl_check.stub(:verify_cert).and_return(true) - ssl_check.stub(:verify_cert_host).and_return(true) + allow(ssl_check).to receive(:trusted_certificates).and_return([trusted_cert_file]) + allow(store).to receive(:add_cert).with(certificate) + allow(OpenSSL::X509::Store).to receive(:new).and_return(store) + allow(OpenSSL::X509::Certificate).to receive(:new).with(IO.read(trusted_cert_file)).and_return(certificate) + allow(ssl_check).to receive(:verify_cert).and_return(true) + allow(ssl_check).to receive(:verify_cert_host).and_return(true) end context "when the trusted certificates have valid X509 properties" do before do - store.stub(:verify).with(certificate).and_return(true) + allow(store).to receive(:verify).with(certificate).and_return(true) end it "does not generate any X509 warnings" do @@ -127,8 +127,8 @@ E context "when the trusted certificates have invalid X509 properties" do before do - store.stub(:verify).with(certificate).and_return(false) - store.stub(:error_string).and_return("unable to get local issuer certificate") + allow(store).to receive(:verify).with(certificate).and_return(false) + allow(store).to receive(:error_string).and_return("unable to get local issuer certificate") end it "generates a warning message with invalid certificate file names" do @@ -145,8 +145,8 @@ E let(:ssl_socket) { double(OpenSSL::SSL::SSLSocket) } before do - TCPSocket.should_receive(:new).with("foo.example.com", 8443).and_return(tcp_socket) - OpenSSL::SSL::SSLSocket.should_receive(:new).with(tcp_socket, ssl_check.verify_peer_ssl_context).and_return(ssl_socket) + expect(TCPSocket).to receive(:new).with("foo.example.com", 8443).and_return(tcp_socket) + expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, ssl_check.verify_peer_ssl_context).and_return(ssl_socket) end def run @@ -160,9 +160,9 @@ E context "when the remote host's certificate is valid" do before do - ssl_check.should_receive(:verify_X509).and_return(true) # X509 valid certs (no warn) - ssl_socket.should_receive(:connect) # no error - ssl_socket.should_receive(:post_connection_check).with("foo.example.com") # no error + expect(ssl_check).to receive(:verify_X509).and_return(true) # X509 valid certs (no warn) + expect(ssl_socket).to receive(:connect) # no error + expect(ssl_socket).to receive(:post_connection_check).with("foo.example.com") # no error end it "prints a success message" do @@ -182,23 +182,23 @@ E before do trap(:INT, "DEFAULT") - TCPSocket.should_receive(:new). + expect(TCPSocket).to receive(:new). with("foo.example.com", 8443). and_return(tcp_socket_for_debug) - OpenSSL::SSL::SSLSocket.should_receive(:new). + expect(OpenSSL::SSL::SSLSocket).to receive(:new). with(tcp_socket_for_debug, ssl_check.noverify_peer_ssl_context). and_return(ssl_socket_for_debug) end context "when the certificate's CN does not match the hostname" do before do - ssl_check.should_receive(:verify_X509).and_return(true) # X509 valid certs - ssl_socket.should_receive(:connect) # no error - ssl_socket.should_receive(:post_connection_check). + expect(ssl_check).to receive(:verify_X509).and_return(true) # X509 valid certs + expect(ssl_socket).to receive(:connect) # no error + expect(ssl_socket).to receive(:post_connection_check). with("foo.example.com"). and_raise(OpenSSL::SSL::SSLError) - ssl_socket_for_debug.should_receive(:connect) - ssl_socket_for_debug.should_receive(:peer_cert).and_return(self_signed_crt) + expect(ssl_socket_for_debug).to receive(:connect) + expect(ssl_socket_for_debug).to receive(:peer_cert).and_return(self_signed_crt) end it "shows the CN used by the certificate and prints an error" do @@ -212,11 +212,11 @@ E context "when the cert is not signed by any trusted authority" do before do - ssl_check.should_receive(:verify_X509).and_return(true) # X509 valid certs - ssl_socket.should_receive(:connect). + expect(ssl_check).to receive(:verify_X509).and_return(true) # X509 valid certs + expect(ssl_socket).to receive(:connect). and_raise(OpenSSL::SSL::SSLError) - ssl_socket_for_debug.should_receive(:connect) - ssl_socket_for_debug.should_receive(:peer_cert).and_return(self_signed_crt) + expect(ssl_socket_for_debug).to receive(:connect) + expect(ssl_socket_for_debug).to receive(:peer_cert).and_return(self_signed_crt) end it "shows the CN used by the certificate and prints an error" do diff --git a/spec/unit/knife/ssl_fetch_spec.rb b/spec/unit/knife/ssl_fetch_spec.rb index 0d3c8913f7..24101dbe7a 100644 --- a/spec/unit/knife/ssl_fetch_spec.rb +++ b/spec/unit/knife/ssl_fetch_spec.rb @@ -36,8 +36,8 @@ describe Chef::Knife::SslFetch do subject(:ssl_fetch) do s = Chef::Knife::SslFetch.new s.name_args = name_args - s.ui.stub(:stdout).and_return(stdout_io) - s.ui.stub(:stderr).and_return(stderr_io) + allow(s.ui).to receive(:stdout).and_return(stdout_io) + allow(s.ui).to receive(:stderr).and_return(stderr_io) s end @@ -131,10 +131,10 @@ E before do Chef::Config.trusted_certs_dir = trusted_certs_dir - TCPSocket.should_receive(:new).with("foo.example.com", 8443).and_return(tcp_socket) - OpenSSL::SSL::SSLSocket.should_receive(:new).with(tcp_socket, ssl_fetch.noverify_peer_ssl_context).and_return(ssl_socket) - ssl_socket.should_receive(:connect) - ssl_socket.should_receive(:peer_cert_chain).and_return([self_signed_crt]) + expect(TCPSocket).to receive(:new).with("foo.example.com", 8443).and_return(tcp_socket) + expect(OpenSSL::SSL::SSLSocket).to receive(:new).with(tcp_socket, ssl_fetch.noverify_peer_ssl_context).and_return(ssl_socket) + expect(ssl_socket).to receive(:connect) + expect(ssl_socket).to receive(:peer_cert_chain).and_return([self_signed_crt]) end after do diff --git a/spec/unit/knife/status_spec.rb b/spec/unit/knife/status_spec.rb index bb43dd25e5..2522bc61b1 100644 --- a/spec/unit/knife/status_spec.rb +++ b/spec/unit/knife/status_spec.rb @@ -25,18 +25,18 @@ describe Chef::Knife::Status do n.automatic_attrs["ohai_time"] = 1343845969 end query = double("Chef::Search::Query") - query.stub(:search).and_yield(node) - Chef::Search::Query.stub(:new).and_return(query) + allow(query).to receive(:search).and_yield(node) + allow(Chef::Search::Query).to receive(:new).and_return(query) @knife = Chef::Knife::Status.new @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end describe "run" do it "should not colorize output unless it's writing to a tty" do @knife.run - @stdout.string.match(/foobar/).should_not be_nil - @stdout.string.match(/\e.*ago/).should be_nil + expect(@stdout.string.match(/foobar/)).not_to be_nil + expect(@stdout.string.match(/\e.*ago/)).to be_nil end end end diff --git a/spec/unit/knife/tag_create_spec.rb b/spec/unit/knife/tag_create_spec.rb index bafea8d268..586ec118bd 100644 --- a/spec/unit/knife/tag_create_spec.rb +++ b/spec/unit/knife/tag_create_spec.rb @@ -7,17 +7,17 @@ describe Chef::Knife::TagCreate do @knife.name_args = [ Chef::Config[:node_name], "happytag" ] @node = Chef::Node.new - @node.stub :save - Chef::Node.stub(:load).and_return @node + allow(@node).to receive :save + allow(Chef::Node).to receive(:load).and_return @node @stderr = StringIO.new - @knife.ui.stub(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) end describe "run" do it "can create tags on a node" do @knife.run - @node.tags.should == ["happytag"] - @stderr.string.should match /created tags happytag.+node webmonkey.example.com/i + expect(@node.tags).to eq(["happytag"]) + expect(@stderr.string).to match /created tags happytag.+node webmonkey.example.com/i end end end diff --git a/spec/unit/knife/tag_delete_spec.rb b/spec/unit/knife/tag_delete_spec.rb index 514228f0a2..e7fa108947 100644 --- a/spec/unit/knife/tag_delete_spec.rb +++ b/spec/unit/knife/tag_delete_spec.rb @@ -7,19 +7,19 @@ describe Chef::Knife::TagDelete do @knife.name_args = [ Chef::Config[:node_name], "sadtag" ] @node = Chef::Node.new - @node.stub :save + allow(@node).to receive :save @node.tags << "sadtag" << "happytag" - Chef::Node.stub(:load).and_return @node + allow(Chef::Node).to receive(:load).and_return @node @stderr = StringIO.new - @knife.ui.stub(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) end describe "run" do it "can delete tags on a node" do - @node.tags.should == ["sadtag", "happytag"] + expect(@node.tags).to eq(["sadtag", "happytag"]) @knife.run - @node.tags.should == ["happytag"] - @stderr.string.should match /deleted.+sadtag/i + expect(@node.tags).to eq(["happytag"]) + expect(@stderr.string).to match /deleted.+sadtag/i end end end diff --git a/spec/unit/knife/tag_list_spec.rb b/spec/unit/knife/tag_list_spec.rb index 3724a5c0b7..9c71d22f06 100644 --- a/spec/unit/knife/tag_list_spec.rb +++ b/spec/unit/knife/tag_list_spec.rb @@ -7,16 +7,16 @@ describe Chef::Knife::TagList do @knife.name_args = [ Chef::Config[:node_name], "sadtag" ] @node = Chef::Node.new - @node.stub :save + allow(@node).to receive :save @node.tags << "sadtag" << "happytag" - Chef::Node.stub(:load).and_return @node + allow(Chef::Node).to receive(:load).and_return @node end describe "run" do it "can list tags on a node" do expected = %w(sadtag happytag) - @node.tags.should == expected - @knife.should_receive(:output).with(expected) + expect(@node.tags).to eq(expected) + expect(@knife).to receive(:output).with(expected) @knife.run end end diff --git a/spec/unit/knife/user_create_spec.rb b/spec/unit/knife/user_create_spec.rb index 58ef868053..ad8821cd0e 100644 --- a/spec/unit/knife/user_create_spec.rb +++ b/spec/unit/knife/user_create_spec.rb @@ -26,8 +26,8 @@ describe Chef::Knife::UserCreate do @stdout = StringIO.new @stderr = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) - @knife.ui.stub(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) @knife.name_args = [ 'a_user' ] @knife.config[:user_password] = "foobar" @@ -36,53 +36,53 @@ describe Chef::Knife::UserCreate do @user_with_private_key = Chef::User.new @user_with_private_key.name "a_user" @user_with_private_key.private_key 'private_key' - @user.stub(:create).and_return(@user_with_private_key) - Chef::User.stub(:new).and_return(@user) - Chef::User.stub(:from_hash).and_return(@user) - @knife.stub(:edit_data).and_return(@user.to_hash) + allow(@user).to receive(:create).and_return(@user_with_private_key) + allow(Chef::User).to receive(:new).and_return(@user) + allow(Chef::User).to receive(:from_hash).and_return(@user) + allow(@knife).to receive(:edit_data).and_return(@user.to_hash) end it "creates a new user" do - Chef::User.should_receive(:new).and_return(@user) - @user.should_receive(:create) + expect(Chef::User).to receive(:new).and_return(@user) + expect(@user).to receive(:create) @knife.run - @stderr.string.should match /created user.+a_user/i + expect(@stderr.string).to match /created user.+a_user/i end it "sets the password" do @knife.config[:user_password] = "a_password" - @user.should_receive(:password).with("a_password") + expect(@user).to receive(:password).with("a_password") @knife.run end it "exits with an error if password is blank" do @knife.config[:user_password] = '' - lambda { @knife.run }.should raise_error SystemExit - @stderr.string.should match /You must specify a non-blank password/ + expect { @knife.run }.to raise_error SystemExit + expect(@stderr.string).to match /You must specify a non-blank password/ end it "sets the user name" do - @user.should_receive(:name).with("a_user") + expect(@user).to receive(:name).with("a_user") @knife.run end it "sets the public key if given" do @knife.config[:user_key] = "/a/filename" - File.stub(:read).with(File.expand_path("/a/filename")).and_return("a_key") - @user.should_receive(:public_key).with("a_key") + allow(File).to receive(:read).with(File.expand_path("/a/filename")).and_return("a_key") + expect(@user).to receive(:public_key).with("a_key") @knife.run end it "allows you to edit the data" do - @knife.should_receive(:edit_data).with(@user) + expect(@knife).to receive(:edit_data).with(@user) @knife.run end it "writes the private key to a file when --file is specified" do @knife.config[:file] = "/tmp/a_file" filehandle = double("filehandle") - filehandle.should_receive(:print).with('private_key') - File.should_receive(:open).with("/tmp/a_file", "w").and_yield(filehandle) + expect(filehandle).to receive(:print).with('private_key') + expect(File).to receive(:open).with("/tmp/a_file", "w").and_yield(filehandle) @knife.run end end diff --git a/spec/unit/knife/user_delete_spec.rb b/spec/unit/knife/user_delete_spec.rb index be027e5128..94cfbf3db1 100644 --- a/spec/unit/knife/user_delete_spec.rb +++ b/spec/unit/knife/user_delete_spec.rb @@ -26,14 +26,14 @@ describe Chef::Knife::UserDelete do end it 'deletes the user' do - @knife.should_receive(:delete_object).with(Chef::User, 'my_user') + expect(@knife).to receive(:delete_object).with(Chef::User, 'my_user') @knife.run end it 'prints usage and exits when a user name is not provided' do @knife.name_args = [] - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end end diff --git a/spec/unit/knife/user_edit_spec.rb b/spec/unit/knife/user_edit_spec.rb index 20a4c0d9e9..0eb75cfa9b 100644 --- a/spec/unit/knife/user_edit_spec.rb +++ b/spec/unit/knife/user_edit_spec.rb @@ -25,23 +25,23 @@ describe Chef::Knife::UserEdit do Chef::Knife::UserEdit.load_deps @knife = Chef::Knife::UserEdit.new - @knife.ui.stub(:stderr).and_return(@stderr) - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stderr).and_return(@stderr) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) @knife.name_args = [ 'my_user' ] @knife.config[:disable_editing] = true end it 'loads and edits the user' do data = { :name => "my_user" } - Chef::User.stub(:load).with("my_user").and_return(data) - @knife.should_receive(:edit_data).with(data).and_return(data) + allow(Chef::User).to receive(:load).with("my_user").and_return(data) + expect(@knife).to receive(:edit_data).with(data).and_return(data) @knife.run end it 'prints usage and exits when a user name is not provided' do @knife.name_args = [] - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end end diff --git a/spec/unit/knife/user_list_spec.rb b/spec/unit/knife/user_list_spec.rb index 7a47f9ddba..db097a5c16 100644 --- a/spec/unit/knife/user_list_spec.rb +++ b/spec/unit/knife/user_list_spec.rb @@ -25,8 +25,8 @@ describe Chef::Knife::UserList do end it 'lists the users' do - Chef::User.should_receive(:list) - @knife.should_receive(:format_list_for_display) + expect(Chef::User).to receive(:list) + expect(@knife).to receive(:format_list_for_display) @knife.run end end diff --git a/spec/unit/knife/user_reregister_spec.rb b/spec/unit/knife/user_reregister_spec.rb index 1cbbdb47d2..1268716f40 100644 --- a/spec/unit/knife/user_reregister_spec.rb +++ b/spec/unit/knife/user_reregister_spec.rb @@ -24,30 +24,30 @@ describe Chef::Knife::UserReregister do @knife = Chef::Knife::UserReregister.new @knife.name_args = [ 'a_user' ] @user_mock = double('user_mock', :private_key => "private_key") - Chef::User.stub(:load).and_return(@user_mock) + allow(Chef::User).to receive(:load).and_return(@user_mock) @stdout = StringIO.new - @knife.ui.stub(:stdout).and_return(@stdout) + allow(@knife.ui).to receive(:stdout).and_return(@stdout) end it 'prints usage and exits when a user name is not provided' do @knife.name_args = [] - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end it 'reregisters the user and prints the key' do - @user_mock.should_receive(:reregister).and_return(@user_mock) + expect(@user_mock).to receive(:reregister).and_return(@user_mock) @knife.run - @stdout.string.should match( /private_key/ ) + expect(@stdout.string).to match( /private_key/ ) end it 'writes the private key to a file when --file is specified' do - @user_mock.should_receive(:reregister).and_return(@user_mock) + expect(@user_mock).to receive(:reregister).and_return(@user_mock) @knife.config[:file] = '/tmp/a_file' filehandle = StringIO.new - File.should_receive(:open).with('/tmp/a_file', 'w').and_yield(filehandle) + expect(File).to receive(:open).with('/tmp/a_file', 'w').and_yield(filehandle) @knife.run - filehandle.string.should == "private_key" + expect(filehandle.string).to eq("private_key") end end diff --git a/spec/unit/knife/user_show_spec.rb b/spec/unit/knife/user_show_spec.rb index af8485ad7d..f97cbc3f13 100644 --- a/spec/unit/knife/user_show_spec.rb +++ b/spec/unit/knife/user_show_spec.rb @@ -27,15 +27,15 @@ describe Chef::Knife::UserShow do end it 'loads and displays the user' do - Chef::User.should_receive(:load).with('my_user').and_return(@user_mock) - @knife.should_receive(:format_for_display).with(@user_mock) + expect(Chef::User).to receive(:load).with('my_user').and_return(@user_mock) + expect(@knife).to receive(:format_for_display).with(@user_mock) @knife.run end it 'prints usage and exits when a user name is not provided' do @knife.name_args = [] - @knife.should_receive(:show_usage) - @knife.ui.should_receive(:fatal) - lambda { @knife.run }.should raise_error(SystemExit) + expect(@knife).to receive(:show_usage) + expect(@knife.ui).to receive(:fatal) + expect { @knife.run }.to raise_error(SystemExit) end end |