knife-server 1.1.0 → 1.2.0

data/spec/chef/knife/server_bootstrap_ec2_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 #
 # Author:: Fletcher Nichol (<fnichol@nichol.ca>)
 # Copyright:: Copyright (c) 2012 Fletcher Nichol
@@ -16,10 +17,10 @@
 # limitations under the License.
 #
 
-require 'chef/knife/server_bootstrap_ec2'
-require 'chef/knife/ssh'
-require 'fakefs/spec_helpers'
-require 'net/ssh'
+require "chef/knife/server_bootstrap_ec2"
+require "chef/knife/ssh"
+require "fakefs/spec_helpers"
+require "net/ssh"
 Chef::Knife::ServerBootstrapEc2.load_deps
 
 describe Chef::Knife::ServerBootstrapEc2 do
@@ -29,15 +30,15 @@ describe Chef::Knife::ServerBootstrapEc2 do
     Chef::Log.logger = Logger.new(StringIO.new)
     @knife = Chef::Knife::ServerBootstrapEc2.new
     @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)
     @knife.config[:chef_node_name] = "yakky"
     @knife.config[:platform] = "omnibus"
     @knife.config[:ssh_user] = "root"
   end
 
-  let(:connection) { mock(Fog::Compute::AWS) }
+  let(:connection) { double(Fog::Compute::AWS) }
 
   describe "#ec2_bootstrap" do
     before do
@@ -45,94 +46,100 @@ describe Chef::Knife::ServerBootstrapEc2 do
       @knife.config[:ssh_user] = "jdoe"
       @knife.config[:ssh_port] = "2222"
       @knife.config[:identity_file] = "~/.ssh/mykey_dsa"
-      @knife.config[:security_groups] = %w{x y z}
-      @knife.config[:tags] = %w{tag1=val1 tag2=val2}
+      @knife.config[:security_groups] = %w[x y z]
+      @knife.config[:tags] = %w[tag1=val1 tag2=val2]
       @knife.config[:distro] = "distro-praha"
       @knife.config[:ebs_size] = "42"
       @knife.config[:webui_password] = "daweb"
       @knife.config[:amqp_password] = "queueitup"
 
-      ENV['_SPEC_WEBUI_PASSWORD'] = ENV['WEBUI_PASSWORD']
-      ENV['_SPEC_AMQP_PASSWORD'] = ENV['AMQP_PASSWORD']
+      ENV["_SPEC_WEBUI_PASSWORD"] = ENV["WEBUI_PASSWORD"]
+      ENV["_SPEC_AMQP_PASSWORD"] = ENV["AMQP_PASSWORD"]
     end
 
     after do
-      ENV['WEBUI_PASSWORD'] = ENV.delete('_SPEC_WEBUI_PASSWORD')
-      ENV['AMQP_PASSWORD'] = ENV.delete('_SPEC_AMQP_PASSWORD')
+      ENV["WEBUI_PASSWORD"] = ENV.delete("_SPEC_WEBUI_PASSWORD")
+      ENV["AMQP_PASSWORD"] = ENV.delete("_SPEC_AMQP_PASSWORD")
     end
 
     let(:bootstrap) { @knife.ec2_bootstrap }
 
     it "returns an Ec2ServerCreate instance" do
-      bootstrap.should be_a(Chef::Knife::Ec2ServerCreate)
+      expect(bootstrap).to be_a(Chef::Knife::Ec2ServerCreate)
     end
 
     it "configs the bootstrap's chef_node_name" do
-      bootstrap.config[:chef_node_name].should eq("shave.yak")
+      expect(bootstrap.config[:chef_node_name]).to eq("shave.yak")
     end
 
     it "configs the bootstrap's ssh_user" do
-      bootstrap.config[:ssh_user].should eq("jdoe")
+      expect(bootstrap.config[:ssh_user]).to eq("jdoe")
     end
 
     it "configs the bootstrap's ssh_port" do
-      bootstrap.config[:ssh_port].should eq("2222")
+      expect(bootstrap.config[:ssh_port]).to eq("2222")
     end
 
     it "configs the bootstrap's identity_file" do
-      bootstrap.config[:identity_file].should eq("~/.ssh/mykey_dsa")
+      expect(bootstrap.config[:identity_file]).to eq("~/.ssh/mykey_dsa")
     end
 
     it "configs the bootstrap's security_groups" do
-      bootstrap.config[:security_groups].should eq(["x", "y", "z"])
+      expect(bootstrap.config[:security_groups]).to eq(%w[x y z])
     end
 
     it "configs the bootstrap's ebs_size" do
-      bootstrap.config[:ebs_size].should eq("42")
+      expect(bootstrap.config[:ebs_size]).to eq("42")
     end
 
     it "configs the bootstrap's tags" do
-      bootstrap.config[:tags].should include("tag1=val1")
-      bootstrap.config[:tags].should include("tag2=val2")
+      expect(bootstrap.config[:tags]).to include("tag1=val1")
+      expect(bootstrap.config[:tags]).to include("tag2=val2")
     end
 
     it "adds Role=chef_server to the bootstrap's tags" do
-      bootstrap.config[:tags].should include("Role=chef_server")
+      expect(bootstrap.config[:tags]).to include("Role=chef_server")
     end
 
     it "configs the bootstrap's distro" do
-      bootstrap.config[:distro].should eq("distro-praha")
+      expect(bootstrap.config[:distro]).to eq("distro-praha")
     end
 
     it "configs the bootstrap's distro to chef11/omnibus by default" do
       @knife.config.delete(:distro)
 
-      bootstrap.config[:distro].should eq("chef11/omnibus")
+      expect(bootstrap.config[:distro]).to eq("chef11/omnibus")
     end
 
     it "configs the bootstrap's distro value driven off platform value" do
       @knife.config.delete(:distro)
       @knife.config[:platform] = "freebsd"
 
-      bootstrap.config[:distro].should eq("chef11/freebsd")
+      expect(bootstrap.config[:distro]).to eq("chef11/freebsd")
     end
 
-    it "configs the bootstrap's distro based on bootstrap_version and platform" do
+    it "configs the distro based on bootstrap_version and platform" do
       @knife.config.delete(:distro)
       @knife.config[:platform] = "freebsd"
       @knife.config[:bootstrap_version] = "10"
 
-      bootstrap.config[:distro].should eq("chef10/freebsd")
+      expect(bootstrap.config[:distro]).to eq("chef10/freebsd")
     end
 
     it "configs the bootstrap's ENV with the webui password" do
       bootstrap
-      ENV['WEBUI_PASSWORD'].should eq("daweb")
+
+      expect(ENV["WEBUI_PASSWORD"]).to eq("daweb")
     end
 
     it "configs the bootstrap's ENV with the amqp password" do
       bootstrap
-      ENV['AMQP_PASSWORD'].should eq("queueitup")
+
+      expect(ENV["AMQP_PASSWORD"]).to eq("queueitup")
+    end
+
+    it "skips config values with nil defaults" do
+      expect(bootstrap.config[:bootstrap_version]).to be_nil
     end
   end
 
@@ -156,12 +163,12 @@ describe Chef::Knife::ServerBootstrapEc2 do
     end
 
     it "constructs a connection" do
-      Fog::Compute.should_receive(:new).with({
-        :provider => 'AWS',
-        :aws_access_key_id => 'key',
-        :aws_secret_access_key => 'secret',
-        :region => 'hell-south-666'
-      })
+      expect(Fog::Compute).to receive(:new).with(
+        :provider => "AWS",
+        :aws_access_key_id => "key",
+        :aws_secret_access_key => "secret",
+        :region => "hell-south-666"
+      )
 
       @knife.ec2_connection
     end
@@ -169,37 +176,41 @@ describe Chef::Knife::ServerBootstrapEc2 do
 
   describe "#server_dns_name" do
     before do
-      @knife.config[:chef_node_name] = 'shavemy.yak'
-      @knife.stub(:ec2_connection) { connection }
+      @knife.config[:chef_node_name] = "shavemy.yak"
+      allow(@knife).to receive(:ec2_connection) { connection }
     end
 
     context "when server is found" do
       before do
-        connection.stub(:servers) { [server] }
+        expect(connection).to receive(:servers) { [server] }
       end
 
       let(:server) do
-        stub(:dns_name => 'blahblah.aws.compute.com', :state => "running",
-          :tags => {'Name' => 'shavemy.yak', 'Role' => 'chef_server'})
+        double(
+          :dns_name => "blahblah.aws.compute.com",
+          :state => "running",
+          :tags => { "Name" => "shavemy.yak", "Role" => "chef_server" }
+        )
       end
 
       it "returns the provisioned dns name" do
-        @knife.server_dns_name.should eq('blahblah.aws.compute.com')
+        expect(@knife.server_dns_name).to eq("blahblah.aws.compute.com")
       end
 
       it "ignores terminated instances" do
-        server.stub(:state) { "terminated" }
-        @knife.server_dns_name.should be_nil
+        allow(server).to receive(:state) { "terminated" }
+
+        expect(@knife.server_dns_name).to be_nil
       end
     end
 
     context "when server is not found" do
       before do
-        connection.stub(:servers) { [] }
+        allow(connection).to receive(:servers) { [] }
       end
 
       it "returns nil" do
-        @knife.server_dns_name.should be_nil
+        expect(@knife.server_dns_name).to be_nil
       end
     end
   end
@@ -217,15 +228,15 @@ describe Chef::Knife::ServerBootstrapEc2 do
       @knife.config[:validation_key] = "/var/tmp/validation.pem"
       @knife.config[:ssh_port] = "2345"
       @knife.config[:identity_file] = "~/.ssh/mykey_dsa"
-      @knife.stub(:ec2_connection)  { connection }
-      @knife.stub(:server_dns_name)  { "grapes.wrath" }
-      Chef::Knife::Ec2ServerCreate.stub(:new) { bootstrap }
-      Knife::Server::Ec2SecurityGroup.stub(:new) { security_group }
-      Knife::Server::SSH.stub(:new) { ssh }
-      Knife::Server::Credentials.stub(:new) { credentials }
-      security_group.stub(:configure_chef_server_group)
-      credentials.stub(:install_validation_key)
-      credentials.stub(:create_root_client)
+      allow(@knife).to receive(:ec2_connection)  { connection }
+      allow(@knife).to receive(:server_dns_name)  { "grapes.wrath" }
+      allow(Chef::Knife::Ec2ServerCreate).to receive(:new) { bootstrap }
+      allow(Knife::Server::Ec2SecurityGroup).to receive(:new) { security_group }
+      allow(Knife::Server::SSH).to receive(:new) { ssh }
+      allow(Knife::Server::Credentials).to receive(:new) { credentials }
+      allow(security_group).to receive(:configure_chef_server_group)
+      allow(credentials).to receive(:install_validation_key)
+      allow(credentials).to receive(:create_root_client)
     end
 
     after do
@@ -234,66 +245,83 @@ describe Chef::Knife::ServerBootstrapEc2 do
       end
     end
 
-    let(:bootstrap)       { stub(:run => true, :config => Hash.new) }
-    let(:security_group)  { stub }
-    let(:ssh)             { stub }
-    let(:credentials)     { stub.as_null_object }
+    let(:bootstrap)       { double(:run => true, :config => Hash.new) }
+    let(:security_group)  { double }
+    let(:ssh)             { double }
+    let(:credentials)     { double.as_null_object }
+
+    it "exits if Chef::Config[:node_name] is missing" do
+      Chef::Config[:node_name] = nil
+
+      expect { @knife.run }.to raise_error SystemExit
+    end
+
+    it "exits if Chef::Config[:client_key] is missing" do
+      Chef::Config[:client_key] = nil
+
+      expect { @knife.run }.to raise_error SystemExit
+    end
 
     it "exits if node_name option is missing" do
-      def @knife.exit(code) ; end
+      def @knife.exit(_); end
       @knife.config.delete(:chef_node_name)
 
-      @knife.should_receive(:exit)
+      expect(@knife).to receive(:exit)
       @knife.run
     end
 
     it "configures the ec2 security group" do
-      Knife::Server::Ec2SecurityGroup.should_receive(:new).
+      expect(Knife::Server::Ec2SecurityGroup).to receive(:new).
         with(connection, @knife.ui)
-      security_group.should_receive(:configure_chef_server_group).
-        with('mygroup', :description => 'mygroup group')
+      expect(security_group).to receive(:configure_chef_server_group).
+        with("mygroup", :description => "mygroup group")
 
       @knife.run
     end
 
     it "bootstraps an ec2 server" do
-      bootstrap.should_receive(:run)
+      expect(bootstrap).to receive(:run)
+
       @knife.run
     end
 
     it "installs a new validation.pem key from the chef 10 server" do
       @knife.config[:bootstrap_version] = "10"
-      Knife::Server::SSH.should_receive(:new).with({
-        :host => "grapes.wrath", :user => "root",
-        :port => "2345", :keys => ["~/.ssh/mykey_dsa"]
-      })
-      Knife::Server::Credentials.should_receive(:new).
+      expect(Knife::Server::SSH).to receive(:new).with(
+        :host => "grapes.wrath",
+        :user => "root",
+        :port => "2345",
+        :keys => ["~/.ssh/mykey_dsa"]
+      )
+      expect(Knife::Server::Credentials).to receive(:new).
         with(ssh, "/etc/chef/validation.pem", {})
-      credentials.should_receive(:install_validation_key)
+      expect(credentials).to receive(:install_validation_key)
 
       @knife.run
     end
 
     it "installs a new validation.pem key from the omnibus server" do
-      Knife::Server::SSH.should_receive(:new).with({
-        :host => "grapes.wrath", :user => "root",
-        :port => "2345", :keys => ["~/.ssh/mykey_dsa"]
-      })
-      Knife::Server::Credentials.should_receive(:new).
-        with(ssh, "/etc/chef/validation.pem", {:omnibus => true})
-      credentials.should_receive(:install_validation_key)
+      expect(Knife::Server::SSH).to receive(:new).with(
+        :host => "grapes.wrath",
+        :user => "root",
+        :port => "2345",
+        :keys => ["~/.ssh/mykey_dsa"]
+      )
+      expect(Knife::Server::Credentials).to receive(:new).
+        with(ssh, "/etc/chef/validation.pem", :omnibus => true)
+      expect(credentials).to receive(:install_validation_key)
 
       @knife.run
     end
 
     it "create a root client key" do
-      credentials.should_receive(:create_root_client)
+      expect(credentials).to receive(:create_root_client)
 
       @knife.run
     end
 
     it "installs a client key" do
-      credentials.should_receive(:install_client_key).
+      expect(credentials).to receive(:install_client_key).
         with("smithers", "/var/tmp/myclientkey.pem")
 
       @knife.run

data/spec/chef/knife/server_bootstrap_linode_spec.rb

@@ -1,3 +1,4 @@
+# -*- encoding: utf-8 -*-
 #
 # Author:: Fletcher Nichol (<fnichol@nichol.ca>)
 # Copyright:: Copyright (c) 2013 Fletcher Nichol
@@ -16,10 +17,10 @@
 # limitations under the License.
 #
 
-require 'chef/knife/server_bootstrap_linode'
-require 'chef/knife/ssh'
-require 'fakefs/spec_helpers'
-require 'net/ssh'
+require "chef/knife/server_bootstrap_linode"
+require "chef/knife/ssh"
+require "fakefs/spec_helpers"
+require "net/ssh"
 Chef::Knife::ServerBootstrapLinode.load_deps
 
 describe Chef::Knife::ServerBootstrapLinode do
@@ -29,15 +30,15 @@ describe Chef::Knife::ServerBootstrapLinode do
     Chef::Log.logger = Logger.new(StringIO.new)
     @knife = Chef::Knife::ServerBootstrapLinode.new
     @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)
     @knife.config[:chef_node_name] = "yakky"
     @knife.config[:platform] = "omnibus"
     @knife.config[:ssh_user] = "root"
   end
 
-  let(:connection) { mock(Fog::Compute::AWS) }
+  let(:connection) { double(Fog::Compute::AWS) }
 
   describe "#linode_bootstrap" do
 
@@ -50,70 +51,76 @@ describe Chef::Knife::ServerBootstrapLinode do
       @knife.config[:webui_password] = "daweb"
       @knife.config[:amqp_password] = "queueitup"
 
-      ENV['_SPEC_WEBUI_PASSWORD'] = ENV['WEBUI_PASSWORD']
-      ENV['_SPEC_AMQP_PASSWORD'] = ENV['AMQP_PASSWORD']
+      ENV["_SPEC_WEBUI_PASSWORD"] = ENV["WEBUI_PASSWORD"]
+      ENV["_SPEC_AMQP_PASSWORD"] = ENV["AMQP_PASSWORD"]
     end
 
     after do
-      ENV['WEBUI_PASSWORD'] = ENV.delete('_SPEC_WEBUI_PASSWORD')
-      ENV['AMQP_PASSWORD'] = ENV.delete('_SPEC_AMQP_PASSWORD')
+      ENV["WEBUI_PASSWORD"] = ENV.delete("_SPEC_WEBUI_PASSWORD")
+      ENV["AMQP_PASSWORD"] = ENV.delete("_SPEC_AMQP_PASSWORD")
     end
 
     let(:bootstrap) { @knife.linode_bootstrap }
 
     it "returns a LinodeServerCreate instance" do
-      bootstrap.should be_a(Chef::Knife::LinodeServerCreate)
+      expect(bootstrap).to be_a(Chef::Knife::LinodeServerCreate)
     end
 
     it "configs the bootstrap's chef_node_name" do
-      bootstrap.config[:chef_node_name].should eq("shave.yak")
+      expect(bootstrap.config[:chef_node_name]).to eq("shave.yak")
     end
 
     it "configs the bootstrap's ssh_user" do
-      bootstrap.config[:ssh_user].should eq("jdoe")
+      expect(bootstrap.config[:ssh_user]).to eq("jdoe")
     end
 
     it "configs the bootstrap's identity_file" do
-      bootstrap.config[:identity_file].should eq("~/.ssh/mykey_dsa")
+      expect(bootstrap.config[:identity_file]).to eq("~/.ssh/mykey_dsa")
     end
 
     it "configs the bootstrap's linode_api_key" do
-      bootstrap.config[:linode_api_key].should eq("linode123")
+      expect(bootstrap.config[:linode_api_key]).to eq("linode123")
     end
 
     it "configs the bootstrap's distro" do
-      bootstrap.config[:distro].should eq("distro-praha")
+      expect(bootstrap.config[:distro]).to eq("distro-praha")
     end
 
     it "configs the bootstrap's distro to chef11/omnibus by default" do
       @knife.config.delete(:distro)
 
-      bootstrap.config[:distro].should eq("chef11/omnibus")
+      expect(bootstrap.config[:distro]).to eq("chef11/omnibus")
     end
 
     it "configs the bootstrap's distro value driven off platform value" do
       @knife.config.delete(:distro)
       @knife.config[:platform] = "freebsd"
 
-      bootstrap.config[:distro].should eq("chef11/freebsd")
+      expect(bootstrap.config[:distro]).to eq("chef11/freebsd")
     end
 
-    it "configs the bootstrap's distro based on bootstrap_version and platform" do
+    it "configs the distro based on bootstrap_version and platform" do
       @knife.config.delete(:distro)
       @knife.config[:platform] = "freebsd"
       @knife.config[:bootstrap_version] = "10"
 
-      bootstrap.config[:distro].should eq("chef10/freebsd")
+      expect(bootstrap.config[:distro]).to eq("chef10/freebsd")
     end
 
     it "configs the bootstrap's ENV with the webui password" do
       bootstrap
-      ENV['WEBUI_PASSWORD'].should eq("daweb")
+
+      expect(ENV["WEBUI_PASSWORD"]).to eq("daweb")
     end
 
     it "configs the bootstrap's ENV with the amqp password" do
       bootstrap
-      ENV['AMQP_PASSWORD'].should eq("queueitup")
+
+      expect(ENV["AMQP_PASSWORD"]).to eq("queueitup")
+    end
+
+    it "skips config values with nil defaults" do
+      expect(bootstrap.config[:bootstrap_version]).to be_nil
     end
   end
 
@@ -134,10 +141,10 @@ describe Chef::Knife::ServerBootstrapLinode do
     end
 
     it "constructs a connection" do
-      Fog::Compute.should_receive(:new).with({
-        :provider => 'Linode',
-        :linode_api_key => 'key'
-      })
+      expect(Fog::Compute).to receive(:new).with(
+        :provider => "Linode",
+        :linode_api_key => "key"
+      )
 
       @knife.linode_connection
     end
@@ -146,38 +153,42 @@ describe Chef::Knife::ServerBootstrapLinode do
   describe "#server_ip_address" do
 
     before do
-      @knife.config[:linode_node_name] = 'yak'
-      @knife.stub(:linode_connection) { connection }
+      @knife.config[:linode_node_name] = "yak"
+      allow(@knife).to receive(:linode_connection) { connection }
     end
 
     context "when server is found" do
 
       before do
-        connection.stub(:servers) { [server] }
+        allow(connection).to receive(:servers) { [server] }
       end
 
       let(:server) do
-        stub(:name => 'yak', :status => 1, :public_ip_address => '10.11.12.13')
+        double(
+          :name => "yak",
+          :status => 1,
+          :public_ip_address => "10.11.12.13"
+        )
       end
 
       it "returns the provisioned ip address" do
-        @knife.server_ip_address.should eq('10.11.12.13')
+        expect(@knife.server_ip_address).to eq("10.11.12.13")
       end
 
       it "ignores terminated instances" do
-        server.stub(:status) { 0 }
+        allow(server).to receive(:status) { 0 }
 
-        @knife.server_ip_address.should be_nil
+        expect(@knife.server_ip_address).to be_nil
       end
     end
 
     context "when server is not found" do
       before do
-        connection.stub(:servers) { [] }
+        allow(connection).to receive(:servers) { [] }
       end
 
       it "returns nil" do
-        @knife.server_ip_address.should be_nil
+        expect(@knife.server_ip_address).to be_nil
       end
     end
   end
@@ -195,13 +206,13 @@ describe Chef::Knife::ServerBootstrapLinode do
       @knife.config[:validation_key] = "/var/tmp/validation.pem"
       @knife.config[:identity_file] = "~/.ssh/mykey_dsa"
       @knife.config[:ssh_password] = "booboo"
-      @knife.stub(:linode_connection)  { connection }
-      @knife.stub(:server_ip_address)  { "11.11.11.13" }
-      Chef::Knife::LinodeServerCreate.stub(:new) { bootstrap }
-      Knife::Server::SSH.stub(:new) { ssh }
-      Knife::Server::Credentials.stub(:new) { credentials }
-      credentials.stub(:install_validation_key)
-      credentials.stub(:create_root_client)
+      allow(@knife).to receive(:linode_connection)  { connection }
+      allow(@knife).to receive(:server_ip_address)  { "11.11.11.13" }
+      allow(Chef::Knife::LinodeServerCreate).to receive(:new) { bootstrap }
+      allow(Knife::Server::SSH).to receive(:new) { ssh }
+      allow(Knife::Server::Credentials).to receive(:new) { credentials }
+      allow(credentials).to receive(:install_validation_key)
+      allow(credentials).to receive(:create_root_client)
     end
 
     after do
@@ -210,61 +221,79 @@ describe Chef::Knife::ServerBootstrapLinode do
       end
     end
 
-    let(:bootstrap)   { stub(:run => true, :config => Hash.new) }
-    let(:ssh)         { stub }
-    let(:credentials) { stub.as_null_object }
+    let(:bootstrap)   { double(:run => true, :config => Hash.new) }
+    let(:ssh)         { double }
+    let(:credentials) { double.as_null_object }
+
+    it "exits if Chef::Config[:node_name] is missing" do
+      Chef::Config[:node_name] = nil
+
+      expect { @knife.run }.to raise_error SystemExit
+    end
+
+    it "exits if Chef::Config[:client_key] is missing" do
+      Chef::Config[:client_key] = nil
+
+      expect { @knife.run }.to raise_error SystemExit
+    end
 
     it "exits if node_name option is missing" do
       @knife.config.delete(:chef_node_name)
 
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     it "exits if platform is set to auto" do
       @knife.config[:platform] = "auto"
 
-      lambda { @knife.run }.should raise_error(SystemExit)
+      expect { @knife.run }.to raise_error(SystemExit)
     end
 
     it "bootstraps a linode server" do
-      bootstrap.should_receive(:run)
+      expect(bootstrap).to receive(:run)
 
       @knife.run
     end
 
     it "installs a new validation.pem key from the chef 10 server" do
       @knife.config[:bootstrap_version] = "10"
-      Knife::Server::SSH.should_receive(:new).with({
-        :host => "11.11.11.13", :user => "root",
-        :port => "22", :keys => ["~/.ssh/mykey_dsa"], :password => "booboo"
-      })
-      Knife::Server::Credentials.should_receive(:new).
+      expect(Knife::Server::SSH).to receive(:new).with(
+        :host => "11.11.11.13",
+        :user => "root",
+        :port => "22",
+        :keys => ["~/.ssh/mykey_dsa"],
+        :password => "booboo"
+      )
+      expect(Knife::Server::Credentials).to receive(:new).
         with(ssh, "/etc/chef/validation.pem", {})
-      credentials.should_receive(:install_validation_key)
+      expect(credentials).to receive(:install_validation_key)
 
       @knife.run
     end
 
     it "installs a new validation.pem key from the omnibus server" do
-      Knife::Server::SSH.should_receive(:new).with({
-        :host => "11.11.11.13", :user => "root",
-        :port => "22", :keys => ["~/.ssh/mykey_dsa"], :password => "booboo"
-      })
-      Knife::Server::Credentials.should_receive(:new).
-        with(ssh, "/etc/chef/validation.pem", {:omnibus => true})
-      credentials.should_receive(:install_validation_key)
+      expect(Knife::Server::SSH).to receive(:new).with(
+        :host => "11.11.11.13",
+        :user => "root",
+        :port => "22",
+        :keys => ["~/.ssh/mykey_dsa"],
+        :password => "booboo"
+      )
+      expect(Knife::Server::Credentials).to receive(:new).
+        with(ssh, "/etc/chef/validation.pem", :omnibus => true)
+      expect(credentials).to receive(:install_validation_key)
 
       @knife.run
     end
 
     it "create a root client key" do
-      credentials.should_receive(:create_root_client)
+      expect(credentials).to receive(:create_root_client)
 
       @knife.run
     end
 
     it "installs a client key" do
-      credentials.should_receive(:install_client_key).
+      expect(credentials).to receive(:install_client_key).
         with("smithers", "/var/tmp/myclientkey.pem")
 
       @knife.run