knife-server 1.1.0 → 1.2.0

data/spec/chef/knife/server_bootstrap_openstack_spec.rb

@@ -0,0 +1,305 @@
+# -*- encoding: utf-8 -*-
+#
+# Author:: John Bellone (<jbellone@bloomberg.net>)
+# Copyright:: Copyright (c) 2014 Bloomberg Finance L.P.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+require "chef/knife/server_bootstrap_openstack"
+require "chef/knife/ssh"
+require "fakefs/spec_helpers"
+require "net/ssh"
+Chef::Knife::ServerBootstrapOpenstack.load_deps
+
+describe Chef::Knife::ServerBootstrapOpenstack do
+  include FakeFS::SpecHelpers
+
+  before do
+    Chef::Log.logger = Logger.new(StringIO.new)
+    @knife = Chef::Knife::ServerBootstrapOpenstack.new
+    @stdout = StringIO.new
+    allow(@knife.ui).to receive(:stdout).and_return(@stdout)
+    @stderr = StringIO.new
+    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) { double(Fog::Compute::AWS) }
+
+  describe "#openstack_bootstrap" do
+
+    before do
+      @knife.config[:chef_node_name] = "shave.yak"
+      @knife.config[:ssh_user] = "jdoe"
+      @knife.config[:identity_file] = "~/.ssh/mykey_dsa"
+      @knife.config[:openstack_password] = "openstack123"
+      @knife.config[:distro] = "distro-praha"
+      @knife.config[:webui_password] = "daweb"
+      @knife.config[:amqp_password] = "queueitup"
+
+      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")
+    end
+
+    let(:bootstrap) { @knife.openstack_bootstrap }
+
+    it "returns a OpenstackServerCreate instance" do
+      expect(bootstrap).to be_a(Chef::Knife::OpenstackServerCreate)
+    end
+
+    it "configs the bootstrap's chef_node_name" do
+      expect(bootstrap.config[:chef_node_name]).to eq("shave.yak")
+    end
+
+    it "configs the bootstrap's ssh_user" do
+      expect(bootstrap.config[:ssh_user]).to eq("jdoe")
+    end
+
+    it "configs the bootstrap's identity_file" do
+      expect(bootstrap.config[:identity_file]).to eq("~/.ssh/mykey_dsa")
+    end
+
+    it "configs the bootstrap's openstack_password" do
+      expect(bootstrap.config[:openstack_password]).to eq("openstack123")
+    end
+
+    it "configs the bootstrap's distro" do
+      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)
+
+      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"
+
+      expect(bootstrap.config[:distro]).to eq("chef11/freebsd")
+    end
+
+    it "configs bootstrap's distro based on bootstrap_version and platform" do
+      @knife.config.delete(:distro)
+      @knife.config[:platform] = "freebsd"
+      @knife.config[:bootstrap_version] = "10"
+
+      expect(bootstrap.config[:distro]).to eq("chef10/freebsd")
+    end
+
+    it "configs the bootstrap's ENV with the webui password" do
+      bootstrap
+
+      expect(ENV["WEBUI_PASSWORD"]).to eq("daweb")
+    end
+
+    it "configs the bootstrap's ENV with the amqp password" do
+      bootstrap
+
+      expect(ENV["AMQP_PASSWORD"]).to eq("queueitup")
+    end
+  end
+
+  describe "#openstack_connection" do
+
+    before do
+      @before_config = Hash.new
+      @before_config[:knife] = Chef::Config[:knife]
+
+      Chef::Config[:knife] = {
+        :openstack_username => "jbellone",
+        :openstack_password => "key",
+        :openstack_auth_url => "http://0.0.0.0",
+        :openstack_tenant   => "slumlord",
+        :openstack_region   => "newyork"
+      }
+    end
+
+    after do
+      Chef::Config[:knife] = @before_config[:knife]
+    end
+
+    it "constructs a connection" do
+      expect(Fog::Compute).to receive(:new).with(
+        :provider => :openstack,
+        :openstack_username => "jbellone",
+        :openstack_password => "key",
+        :openstack_auth_url => "http://0.0.0.0",
+        :openstack_tenant   => "slumlord",
+        :openstack_region   => "newyork"
+      )
+
+      @knife.openstack_connection
+    end
+  end
+
+  describe "#server_ip_address" do
+
+    before do
+      @knife.config[:openstack_node_name] = "yak"
+      allow(@knife).to receive(:openstack_connection) { connection }
+    end
+
+    context "when server is found" do
+
+      before do
+        allow(connection).to receive(:servers) { [server] }
+      end
+
+      let(:server) do
+        double(
+          :name => "yak",
+          :status => 1,
+          :public_ip_address => "10.11.12.13"
+        )
+      end
+
+      it "returns the provisioned ip address" do
+        expect(@knife.server_ip_address).to eq("10.11.12.13")
+      end
+
+      it "ignores terminated instances" do
+        allow(server).to receive(:status) { 0 }
+
+        expect(@knife.server_ip_address).to be_nil
+      end
+    end
+
+    context "when server is not found" do
+      before do
+        allow(connection).to receive(:servers) { [] }
+      end
+
+      it "returns nil" do
+        expect(@knife.server_ip_address).to be_nil
+      end
+    end
+  end
+
+  describe "#run" do
+
+    before do
+      @before_config = Hash.new
+      [:node_name, :client_key].each do |attr|
+        @before_config[attr] = Chef::Config[attr]
+      end
+      Chef::Config[:node_name] = "smithers"
+      Chef::Config[:client_key] = "/var/tmp/myclientkey.pem"
+
+      @knife.config[:validation_key] = "/var/tmp/validation.pem"
+      @knife.config[:identity_file] = "~/.ssh/mykey_dsa"
+      @knife.config[:ssh_password] = "booboo"
+      allow(@knife).to receive(:openstack_connection)  { connection }
+      allow(@knife).to receive(:server_ip_address)  { "11.11.11.13" }
+      allow(Chef::Knife::OpenstackServerCreate).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
+      [:node_name, :client_key].each do |attr|
+        Chef::Config[attr] = @before_config[attr]
+      end
+    end
+
+    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)
+
+      expect { @knife.run }.to raise_error(SystemExit)
+    end
+
+    it "exits if platform is set to auto" do
+      @knife.config[:platform] = "auto"
+
+      expect { @knife.run }.to raise_error(SystemExit)
+    end
+
+    it "bootstraps a openstack server" do
+      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"
+      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", {})
+      expect(credentials).to receive(:install_validation_key)
+
+      @knife.run
+    end
+
+    it "installs a new validation.pem key from the omnibus server" do
+      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
+      expect(credentials).to receive(:create_root_client)
+
+      @knife.run
+    end
+
+    it "installs a client key" do
+      expect(credentials).to receive(:install_client_key).
+        with("smithers", "/var/tmp/myclientkey.pem")
+
+      @knife.run
+    end
+  end
+end

data/spec/chef/knife/server_bootstrap_standalone_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_standalone'
-require 'chef/knife/ssh'
-require 'fakefs/spec_helpers'
-require 'net/ssh'
+require "chef/knife/server_bootstrap_standalone"
+require "chef/knife/ssh"
+require "fakefs/spec_helpers"
+require "net/ssh"
 Chef::Knife::ServerBootstrapStandalone.load_deps
 
 describe Chef::Knife::ServerBootstrapStandalone do
@@ -29,9 +30,9 @@ describe Chef::Knife::ServerBootstrapStandalone do
     Chef::Log.logger = Logger.new(StringIO.new)
     @knife = Chef::Knife::ServerBootstrapStandalone.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[:ssh_user] = "root"
   end
@@ -40,24 +41,26 @@ describe Chef::Knife::ServerBootstrapStandalone do
 
     before do
       @knife.config[:bootstrap_version] = "10"
-      @knife.stub(:determine_platform) { @knife.send(:distro_auto_map, "debian", "6") }
+      allow(@knife).to receive(:determine_platform) do
+        @knife.send(:distro_auto_map, "debian", "6")
+      end
       @knife.config[:platform] = "auto"
     end
 
     it "should auto-select from determine_platform by default" do
       @knife.config.delete(:distro)
-      @knife.send(:bootstrap_distro).should eq("chef10/debian")
-      @knife.stub(:determine_platform) { "chef10/rhel" }
-      @knife.send(:bootstrap_distro).should eq("chef10/rhel")
+      expect(@knife.send(:bootstrap_distro)).to eq("chef10/debian")
+      allow(@knife).to receive(:determine_platform) { "chef10/rhel" }
+      expect(@knife.send(:bootstrap_distro)).to eq("chef10/rhel")
     end
 
-    it "should construct the distro path based on the chef server version and platform" do
-      @knife.send(:construct_distro, "rhel").should eq("chef10/rhel")
+    it "constructs the distro path based on chef server version and platform" do
+      expect(@knife.send(:construct_distro, "rhel")).to eq("chef10/rhel")
       @knife.config[:bootstrap_version] = "11"
-      @knife.send(:construct_distro, "rhel").should eq("chef11/rhel")
+      expect(@knife.send(:construct_distro, "rhel")).to eq("chef11/rhel")
     end
 
-    it "should map the distro template based on a tuple of (platform, platform_version)" do
+    it "maps the distro template based on a platform/platform_version tuple" do
       {
         "el" => "rhel",
         "redhat" => "rhel",
@@ -69,9 +72,9 @@ describe Chef::Knife::ServerBootstrapStandalone do
         "suse" => "suse"
       }.each do |key, value|
         @knife.config[:bootstrap_version] = "10"
-        @knife.send(:distro_auto_map, key, 0).should eq("chef10/#{value}")
+        expect(@knife.send(:distro_auto_map, key, 0)).to eq("chef10/#{value}")
         @knife.config[:bootstrap_version] = "11"
-        @knife.send(:distro_auto_map, key, 0).should eq("chef11/#{value}")
+        expect(@knife.send(:distro_auto_map, key, 0)).to eq("chef11/#{value}")
       end
     end
   end
@@ -85,114 +88,121 @@ describe Chef::Knife::ServerBootstrapStandalone do
       @knife.config[:ssh_password] = "nevereverguess"
       @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.standalone_bootstrap }
 
     it "returns a Bootstrap instance" do
-      bootstrap.should be_a(Chef::Knife::Bootstrap)
+      expect(bootstrap).to be_a(Chef::Knife::Bootstrap)
     end
 
     it "copies our UI object to the bootstrap object" do
-      bootstrap.ui.object_id.should eq(@knife.ui.object_id)
+      expect(bootstrap.ui.object_id).to eq(@knife.ui.object_id)
     end
 
     it "sets NO_TEST in the environment when the option is provided" do
       @knife.config[:no_test] = true
-      bootstrap.should_not be_nil
-      ENV["NO_TEST"].should eq("1")
+
+      expect(bootstrap).to_not be_nil
+      expect(ENV["NO_TEST"]).to eq("1")
+
       ENV.delete("NO_TEST")
     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_password" do
-      bootstrap.config[:ssh_password].should eq("nevereverguess")
+      expect(bootstrap.config[:ssh_password]).to eq("nevereverguess")
     end
 
     it "does not config the bootstrap's ssh_password if not given" do
       @knife.config.delete(:ssh_password)
 
-      bootstrap.config[:ssh_password].should be_nil
+      expect(bootstrap.config[:ssh_password]).to be_nil
     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 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 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 "configs the bootstrap's name_args with the host" do
-      bootstrap.name_args.should eq([ "172.0.10.21" ])
+      expect(bootstrap.name_args).to eq(%w[172.0.10.21])
     end
 
     it "configs the bootstrap's use_sudo to true if ssh-user is not root" do
-      bootstrap.config[:use_sudo].should be_true
+      expect(bootstrap.config[:use_sudo]).to be_truthy
     end
 
     it "configs the bootstrap's use_sudo to false if ssh-user is root" do
       @knife.config[:ssh_user] = "root"
 
-      bootstrap.config[:use_sudo].should_not be_true
+      expect(bootstrap.config[:use_sudo]).to_not be_truthy
+    end
+
+    it "skips config values with nil defaults" do
+      expect(bootstrap.config[:bootstrap_version]).to be_nil
     end
 
     describe "#bootstrap_auto?" do
-      it "should always be true if it was set via --platform, even if the distro changes" do
+      it "should be true if set via --platform, even if the distro changes" do
         @knife.config[:platform] = "auto"
-        bootstrap.config[:distro].should_not eq("auto")
-        @knife.send(:bootstrap_auto?).should be_true
+        expect(bootstrap.config[:distro]).to_not eq("auto")
+        expect(@knife.send(:bootstrap_auto?)).to be_truthy
       end
     end
-
   end
 
   describe "#run" do
@@ -206,11 +216,11 @@ describe Chef::Knife::ServerBootstrapStandalone do
 
       @knife.config[:host] = "192.168.0.1"
       @knife.config[:ssh_port] = "2345"
-      Chef::Knife::Bootstrap.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(Chef::Knife::Bootstrap).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
@@ -220,11 +230,28 @@ describe Chef::Knife::ServerBootstrapStandalone do
     end
 
     let(:bootstrap) do
-      stub(:run => true, :config => Hash.new, :ui= => true, :name_args= => true)
+      double(
+        :run => true,
+        :config => Hash.new,
+        :ui= => true,
+        :name_args= => true
+      )
     end
 
-    let(:ssh)         { stub(:exec! => true) }
-    let(:credentials) { stub.as_null_object }
+    let(:ssh)         { double(:exec! => true) }
+    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)
@@ -239,18 +266,19 @@ describe Chef::Knife::ServerBootstrapStandalone do
     end
 
     it "bootstraps a standalone server" do
-      bootstrap.should_receive(:run)
+      expect(bootstrap).to receive(:run)
+
       @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
@@ -259,27 +287,30 @@ describe Chef::Knife::ServerBootstrapStandalone do
     it "installs a new validation.pem key from the chef 10 server" do
       @knife.config[:bootstrap_version] = "10"
       @knife.config[:distro] = "yabba-debian"
-      Knife::Server::Credentials.should_receive(:new).
+      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::Credentials.should_receive(:new).
-        with(ssh, "/etc/chef/validation.pem", {:omnibus => true})
-      credentials.should_receive(:install_validation_key)
+      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
 
     context "when an ssh password is missing" do
       it "creates an SSH connection without a password" do
-        Knife::Server::SSH.should_receive(:new).with({
-          :host => "192.168.0.1", :port => "2345",
-          :user => "root", :password => nil, :keys => []
-        })
+        expect(Knife::Server::SSH).to receive(:new).with(
+          :host => "192.168.0.1",
+          :port => "2345",
+          :user => "root",
+          :password => nil,
+          :keys => []
+        )
 
         @knife.run
       end
@@ -291,10 +322,13 @@ describe Chef::Knife::ServerBootstrapStandalone do
       end
 
       it "creates an SSH connection with a password" do
-        Knife::Server::SSH.should_receive(:new).with({
-          :host => "192.168.0.1", :port => "2345",
-          :user => "root", :password => "snoopy", :keys => []
-        })
+        expect(Knife::Server::SSH).to receive(:new).with(
+          :host => "192.168.0.1",
+          :port => "2345",
+          :user => "root",
+          :password => "snoopy",
+          :keys => []
+        )
 
         @knife.run
       end
@@ -306,10 +340,13 @@ describe Chef::Knife::ServerBootstrapStandalone do
       end
 
       it "creates an SSH connection with an identity file" do
-        Knife::Server::SSH.should_receive(:new).with({
-          :host => "192.168.0.1", :port => "2345",
-          :user => "root", :password => nil, :keys => ["poop.pem"]
-        })
+        expect(Knife::Server::SSH).to receive(:new).with(
+          :host => "192.168.0.1",
+          :port => "2345",
+          :user => "root",
+          :password => nil,
+          :keys => ["poop.pem"]
+        )
 
         @knife.run
       end
@@ -317,13 +354,13 @@ describe Chef::Knife::ServerBootstrapStandalone do
 
     context "when key-based ssh authentication fails" do
       before do
-        ssh.stub(:exec!).
+        allow(ssh).to receive(:exec!).
           with("hostname -f") { raise ::Net::SSH::AuthenticationFailed }
-        @knife.ui.stub(:ask)  { "hellacool" }
+        allow(@knife.ui).to receive(:ask)  { "hellacool" }
       end
 
       it "sends a authentication failure message" do
-        @knife.ui.should_receive(:warn).with(/Failed to authenticate/i)
+        expect(@knife.ui).to receive(:warn).with(/Failed to authenticate/i)
 
         @knife.run
       end
@@ -331,7 +368,7 @@ describe Chef::Knife::ServerBootstrapStandalone do
       it "sets the :ssh_password config from user input" do
         @knife.run
 
-        @knife.config[:ssh_password].should eq("hellacool")
+        expect(@knife.config[:ssh_password]).to eq("hellacool")
       end
     end
   end