knife-ec2 0.6.4 → 0.6.6.rc.0

data/lib/chef/knife/ec2_server_delete.rb

@@ -63,6 +63,11 @@ class Chef
       def run
 
         validate!
+        if @name_args.empty? && config[:chef_node_name]
+          ui.info("no instance id is specific, trying to retrieve it from node name")
+          instance_id = fetch_instance_id(config[:chef_node_name])
+          @name_args << instance_id unless instance_id.nil?
+        end
 
         @name_args.each do |instance_id|
 
@@ -75,6 +80,7 @@ class Chef
             msg_pair("Region", connection.instance_variable_get(:@region))
             msg_pair("Availability Zone", @server.availability_zone)
             msg_pair("Security Groups", @server.groups.join(", "))
+            msg_pair("IAM Profile", iam_name_from_profile(@server.iam_instance_profile)) if @server.iam_instance_profile
             msg_pair("SSH Key", @server.key_name)
             msg_pair("Root Device Type", @server.root_device_type)
             msg_pair("Public DNS Name", @server.dns_name)
@@ -90,19 +96,44 @@ class Chef
             ui.warn("Deleted server #{@server.id}")
 
             if config[:purge]
-              thing_to_delete = config[:chef_node_name] || instance_id
+              if config[:chef_node_name]
+                thing_to_delete = config[:chef_node_name]
+              else
+                thing_to_delete = fetch_node_name(instance_id)
+              end
               destroy_item(Chef::Node, thing_to_delete, "node")
               destroy_item(Chef::ApiClient, thing_to_delete, "client")
             else
               ui.warn("Corresponding node and client for the #{instance_id} server were not deleted and remain registered with the Chef Server")
             end
-
           rescue NoMethodError
             ui.error("Could not locate server '#{instance_id}'.  Please verify it was provisioned in the '#{locate_config_value(:region)}' region.")
           end
         end
       end
 
+      def fetch_node_name(instance_id)
+        result = query.search(:node,"ec2_instance_id:#{instance_id}")
+        unless result.first.empty?
+          result.first.first.name
+        else
+          instance_id
+        end
+      end
+
+      def fetch_instance_id(name)
+        result = query.search(:node,"name:#{name}")
+        unless result.first.empty?
+          node = result.first.first
+          if node.attribute?('ec2')
+            node['ec2']['instance_id']
+          end
+        end
+      end
+
+      def query
+        @query ||= Chef::Search::Query.new
+      end
     end
   end
 end

data/lib/chef/knife/ec2_server_list.rb

@@ -34,11 +34,64 @@ class Chef
         :default => true,
         :description => "Do not display name tag in output"
 
+      option :az,
+        :short => "-z",
+        :long => "--availability-zone",
+        :boolean => true,
+        :default => false,
+        :description => "Show availability zones"
+
       option :tags,
         :short => "-t TAG1,TAG2",
         :long => "--tags TAG1,TAG2",
         :description => "List of tags to output"
 
+      def fcolor(flavor)
+        case flavor
+        when "t1.micro"
+          fcolor = :blue
+        when "m1.small"
+          fcolor = :magenta
+        when "m1.medium"
+          fcolor = :cyan
+        when "m1.large"
+          fcolor = :green
+        when "m1.xlarge"
+          fcolor = :red
+        end
+      end
+
+      def azcolor(az)
+        case az
+        when /a$/
+          color = :blue
+        when /b$/
+          color = :green
+        when /c$/
+          color = :red
+        when /d$/
+          color = :magenta
+        else
+          color = :cyan
+        end
+      end
+
+      def groups_with_ids(groups)
+        groups.map{|g| 
+          "#{g} (#{@group_id_hash[g]})"
+        }
+      end
+
+      def vpc_with_name(vpc_id)
+        this_vpc = @vpcs.select{|v| v.id == vpc_id }.first
+        if this_vpc.tags["Name"]
+          vpc_name = this_vpc.tags["Name"]
+          "#{vpc_name} (#{vpc_id})"
+        else
+          vpc_id
+        end
+      end
+
       def run
         $stdout.sync = true
 
@@ -54,6 +107,11 @@ class Chef
           ui.color('Public IP', :bold),
           ui.color('Private IP', :bold),
           ui.color('Flavor', :bold),
+
+          if config[:az]
+            ui.color('AZ', :bold)
+          end,
+
           ui.color('Image', :bold),
           ui.color('SSH Key', :bold),
           ui.color('Security Groups', :bold),
@@ -64,11 +122,16 @@ class Chef
             end
           end,
           
+          ui.color('IAM Profile', :bold),
           ui.color('State', :bold)
         ].flatten.compact
         
         output_column_count = server_list.length
         
+        if !config[:region]
+          ui.warn "No region was specified in knife.rb or as an argument. The default region, us-east-1, will be used:"
+        end
+        
         connection.servers.all.each do |server|
           server_list << server.id.to_s
           
@@ -78,7 +141,19 @@ class Chef
           
           server_list << server.public_ip_address.to_s
           server_list << server.private_ip_address.to_s
-          server_list << server.flavor_id.to_s
+          
+          server_list << ui.color(
+                                  server.flavor_id.to_s,
+                                  fcolor(server.flavor_id.to_s)
+                                )
+
+          if config[:az]
+            server_list << ui.color(
+                                server.availability_zone.to_s,
+                                azcolor(server.availability_zone.to_s)
+                              )
+          end
+
           server_list << server.image_id.to_s
           server_list << server.key_name.to_s
           server_list << server.groups.join(", ")
@@ -89,6 +164,8 @@ class Chef
             end
           end
           
+          server_list << iam_name_from_profile(server.iam_instance_profile)
+
           server_list << begin
             state = server.state.to_s.downcase
             case state
@@ -101,6 +178,7 @@ class Chef
             end
           end
         end
+
         puts ui.list(server_list, :uneven_columns_across, output_column_count)
 
       end

data/lib/knife-ec2/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Ec2
-    VERSION = "0.6.4"
+    VERSION = "0.6.6.rc.0"
     MAJOR, MINOR, TINY = VERSION.split('.')
   end
 end

data/spec/spec_helper.rb

@@ -1,5 +1,6 @@
 $:.unshift File.expand_path('../../lib', __FILE__)
 require 'chef'
+require 'chef/knife/winrm_base'
 require 'chef/knife/ec2_server_create'
 require 'chef/knife/ec2_instance_data'
 require 'chef/knife/ec2_server_delete'

data/spec/unit/ec2_server_create_spec.rb

@@ -19,12 +19,14 @@
 require File.expand_path('../../spec_helper', __FILE__)
 require 'fog'
 require 'chef/knife/bootstrap'
+require 'chef/knife/bootstrap_windows_winrm'
+require 'chef/knife/bootstrap_windows_ssh'
 
 describe Chef::Knife::Ec2ServerCreate do
   before do
     @knife_ec2_create = Chef::Knife::Ec2ServerCreate.new
     @knife_ec2_create.initial_sleep_delay = 0
-    @knife_ec2_create.stub!(:tcp_test_ssh).and_return(true)
+    @knife_ec2_create.stub(:tcp_test_ssh).and_return(true)
 
     {
       :image => 'image',
@@ -35,22 +37,23 @@ describe Chef::Knife::Ec2ServerCreate do
       Chef::Config[:knife][key] = value
     end
 
-    @ec2_connection = mock(Fog::Compute::AWS)
-    @ec2_connection.stub_chain(:tags).and_return mock('create', :create => true)
-    @ec2_connection.stub_chain(:images, :get).and_return mock('ami', :root_device_type => 'not_ebs')
-    @ec2_connection.stub_chain(:addresses).and_return [mock('addesses', {
+    @ec2_connection = double(Fog::Compute::AWS)
+    @ec2_connection.stub_chain(:tags).and_return double('create', :create => true)
+    @ec2_connection.stub_chain(:images, :get).and_return double('ami', :root_device_type => 'not_ebs', :platform => 'linux')
+    @ec2_connection.stub_chain(:addresses).and_return [double('addesses', {
             :domain => 'standard',
             :public_ip => '111.111.111.111',
             :server_id => nil,
             :allocation_id => ''})]
 
 
-    @ec2_servers = mock()
-    @new_ec2_server = mock()
+    @ec2_servers = double()
+    @new_ec2_server = double()
 
     @ec2_server_attribs = { :id => 'i-39382318',
                            :flavor_id => 'm1.small',
                            :image_id => 'ami-47241231',
+                           :placement_group => 'some_placement_group',
                            :availability_zone => 'us-west-1',
                            :key_name => 'my_ssh_key',
                            :groups => ['group1', 'group2'],
@@ -62,7 +65,7 @@ describe Chef::Knife::Ec2ServerCreate do
                            :root_device_type => 'not_ebs' }
 
     @ec2_server_attribs.each_pair do |attrib, value|
-      @new_ec2_server.stub!(attrib).and_return(value)
+      @new_ec2_server.stub(attrib).and_return(value)
     end
   end
 
@@ -75,25 +78,38 @@ describe Chef::Knife::Ec2ServerCreate do
       @eip = "111.111.111.111"
       Fog::Compute::AWS.should_receive(:new).and_return(@ec2_connection)
 
-      @knife_ec2_create.stub!(:puts)
-      @knife_ec2_create.stub!(:print)
+      @knife_ec2_create.stub(:puts)
+      @knife_ec2_create.stub(:print)
       @knife_ec2_create.config[:image] = '12345'
 
       @bootstrap = Chef::Knife::Bootstrap.new
-      Chef::Knife::Bootstrap.stub!(:new).and_return(@bootstrap)
+      Chef::Knife::Bootstrap.stub(:new).and_return(@bootstrap)
       @bootstrap.should_receive(:run)
     end
 
+    it "defaults to a distro of 'chef-full' for a linux instance" do
+      @new_ec2_server.should_receive(:wait_for).and_return(true)
+      @knife_ec2_create.config[:distro] = @knife_ec2_create.options[:distro][:default]
+      @knife_ec2_create.run
+      @bootstrap.config[:distro].should == 'chef-full'
+    end
+
     it "creates an EC2 instance and bootstraps it" do
       @new_ec2_server.should_receive(:wait_for).and_return(true)
       @knife_ec2_create.run
       @knife_ec2_create.server.should_not == nil
     end
 
+    it "should never invoke windows bootstrap for linux instance" do
+      @new_ec2_server.should_receive(:wait_for).and_return(true)
+      @knife_ec2_create.should_not_receive(:bootstrap_for_windows_node)
+      @knife_ec2_create.run
+    end
+
     it "creates an EC2 instance, assigns existing EIP and bootstraps it" do
       @knife_ec2_create.config[:associate_eip] = @eip
 
-      @new_ec2_server.stub!(:public_ip_address).and_return(@eip)
+      @new_ec2_server.stub(:public_ip_address).and_return(@eip)
       @ec2_connection.should_receive(:associate_address).with(@ec2_server_attribs[:id], @eip, nil, '')
       @new_ec2_server.should_receive(:wait_for).at_least(:twice).and_return(true)
 
@@ -111,16 +127,97 @@ describe Chef::Knife::Ec2ServerCreate do
     end
   end
 
+  describe "run for EC2 Windows instance" do
+    before do
+      @ec2_servers.should_receive(:create).and_return(@new_ec2_server)
+      @ec2_connection.should_receive(:servers).and_return(@ec2_servers)
+      @ec2_connection.should_receive(:addresses)
+
+      Fog::Compute::AWS.should_receive(:new).and_return(@ec2_connection)
+
+      @knife_ec2_create.stub(:puts)
+      @knife_ec2_create.stub(:print)
+      @knife_ec2_create.config[:identity_file] = "~/.ssh/aws-key.pem"
+      @knife_ec2_create.config[:image] = '12345'
+      @knife_ec2_create.stub(:is_image_windows?).and_return(true)
+      @knife_ec2_create.stub(:tcp_test_winrm).and_return(true)
+    end
+
+    it "bootstraps via the WinRM protocol" do
+      @knife_ec2_create.config[:winrm_password] = 'winrm-password'
+      @knife_ec2_create.config[:bootstrap_protocol] = 'winrm'
+      @bootstrap_winrm = Chef::Knife::BootstrapWindowsWinrm.new
+      Chef::Knife::BootstrapWindowsWinrm.stub(:new).and_return(@bootstrap_winrm)
+      @bootstrap_winrm.should_receive(:run)
+      @new_ec2_server.should_receive(:wait_for).and_return(true)
+      @knife_ec2_create.run
+    end
+
+    it "set default distro to windows-chef-client-msi for windows" do
+      @knife_ec2_create.config[:winrm_password] = 'winrm-password'
+      @knife_ec2_create.config[:bootstrap_protocol] = 'winrm'      
+      @bootstrap_winrm = Chef::Knife::BootstrapWindowsWinrm.new
+      Chef::Knife::BootstrapWindowsWinrm.stub(:new).and_return(@bootstrap_winrm)
+      @bootstrap_winrm.should_receive(:run)
+      @new_ec2_server.should_receive(:wait_for).and_return(true)
+      @knife_ec2_create.run
+      @knife_ec2_create.config[:distro].should == "windows-chef-client-msi"
+    end
+
+    it "bootstraps via the SSH protocol" do
+      @knife_ec2_create.config[:bootstrap_protocol] = 'ssh'
+      bootstrap_win_ssh = Chef::Knife::BootstrapWindowsSsh.new
+      Chef::Knife::BootstrapWindowsSsh.stub(:new).and_return(bootstrap_win_ssh)
+      bootstrap_win_ssh.should_receive(:run)
+      @new_ec2_server.should_receive(:wait_for).and_return(true)
+      @knife_ec2_create.run
+    end
+
+    it "should use configured SSH port" do
+      @knife_ec2_create.config[:bootstrap_protocol] = 'ssh'
+      @knife_ec2_create.config[:ssh_port] = 422
+
+      @knife_ec2_create.should_receive(:tcp_test_ssh).with('ec2-75.101.253.10.compute-1.amazonaws.com', 422).and_return(true)
+
+      bootstrap_win_ssh = Chef::Knife::BootstrapWindowsSsh.new
+      Chef::Knife::BootstrapWindowsSsh.stub(:new).and_return(bootstrap_win_ssh)
+      bootstrap_win_ssh.should_receive(:run)
+      @new_ec2_server.should_receive(:wait_for).and_return(true)
+      @knife_ec2_create.run
+    end
+
+    it "should never invoke linux bootstrap" do
+      @knife_ec2_create.config[:bootstrap_protocol] = 'winrm'
+      @knife_ec2_create.stub(:windows_password).and_return("")
+      @knife_ec2_create.should_not_receive(:bootstrap_for_linux_node)
+      @new_ec2_server.should_receive(:wait_for).and_return(true)
+      @knife_ec2_create.stub(:bootstrap_for_windows_node).and_return double("bootstrap", :run => true)
+      @knife_ec2_create.run
+    end
+
+    it "waits for EC2 to generate password if not supplied" do
+      @knife_ec2_create.config[:bootstrap_protocol] = 'winrm'
+      @knife_ec2_create.config[:winrm_password] = nil
+      @knife_ec2_create.should_receive(:windows_password).and_return("")
+      @new_ec2_server.stub(:wait_for).and_return(true)
+      @knife_ec2_create.stub(:check_windows_password_available).and_return(true)
+      bootstrap_winrm = Chef::Knife::BootstrapWindowsWinrm.new
+      Chef::Knife::BootstrapWindowsWinrm.stub(:new).and_return(bootstrap_winrm)
+      bootstrap_winrm.should_receive(:run)
+      @knife_ec2_create.run
+    end
+  end
+
   describe "when setting tags" do
     before do
       Fog::Compute::AWS.should_receive(:new).and_return(@ec2_connection)
-      @knife_ec2_create.stub!(:bootstrap_for_node).and_return mock("bootstrap", :run => true)
-      @ec2_connection.stub!(:servers).and_return(@ec2_servers)
+      @knife_ec2_create.stub(:bootstrap_for_linux_node).and_return double("bootstrap", :run => true)
+      @ec2_connection.stub(:servers).and_return(@ec2_servers)
       @ec2_connection.should_receive(:addresses)
-      @new_ec2_server.stub!(:wait_for).and_return(true)
-      @ec2_servers.stub!(:create).and_return(@new_ec2_server)
-      @knife_ec2_create.stub!(:puts)
-      @knife_ec2_create.stub!(:print)
+      @new_ec2_server.stub(:wait_for).and_return(true)
+      @ec2_servers.stub(:create).and_return(@new_ec2_server)
+      @knife_ec2_create.stub(:puts)
+      @knife_ec2_create.stub(:print)
     end
 
     it "sets the Name tag to the instance id by default" do
@@ -156,6 +253,41 @@ describe Chef::Knife::Ec2ServerCreate do
 
   end
 
+  # This shared examples group can be used to house specifications that
+  # are common to both the Linux and Windows bootstraping process. This
+  # would remove a lot of testing duplication that is currently present.
+  shared_examples "generic bootstrap configurations" do
+    context "data bag secret" do
+      before(:each) do
+        Chef::Config[:knife][:secret] = "sys-knife-secret"
+      end
+
+     it "uses the the knife configuration when no explicit value is provided" do
+        expect(bootstrap.config[:secret]).to eql("sys-knife-secret")
+      end
+
+      it "prefers using a provided value instead of the knife confiuration" do
+        subject.config[:secret] = "cli-provided-secret"
+        expect(bootstrap.config[:secret]).to eql("cli-provided-secret")
+      end
+    end
+
+    context "data bag secret file" do
+      before(:each) do
+        Chef::Config[:knife][:secret_file] = "sys-knife-secret-file"
+      end
+
+      it "uses the the knife configuration when no explicit value is provided" do
+        expect(bootstrap.config[:secret_file]).to eql("sys-knife-secret-file")
+      end
+
+      it "prefers using a provided value instead of the knife confiuration" do
+        subject.config[:secret_file] = "cli-provided-secret-file"
+        expect(bootstrap.config[:secret_file]).to eql("cli-provided-secret-file")
+      end
+    end
+  end
+
   describe "when configuring the bootstrap process" do
     before do
       @knife_ec2_create.config[:ssh_user] = "ubuntu"
@@ -168,7 +300,12 @@ describe Chef::Knife::Ec2ServerCreate do
       @knife_ec2_create.config[:run_list] = ['role[base]']
       @knife_ec2_create.config[:json_attributes] = "{'my_attributes':{'foo':'bar'}"
 
-      @bootstrap = @knife_ec2_create.bootstrap_for_node(@new_ec2_server, @new_ec2_server.dns_name)
+      @bootstrap = @knife_ec2_create.bootstrap_for_linux_node(@new_ec2_server, @new_ec2_server.dns_name)
+    end
+
+    include_examples "generic bootstrap configurations" do
+      subject { @knife_ec2_create }
+      let(:bootstrap) { @knife_ec2_create.bootstrap_for_linux_node(@new_ec2_server, @new_ec2_server.dns_name) }
     end
 
     it "should set the bootstrap 'name argument' to the hostname of the EC2 server" do
@@ -206,7 +343,7 @@ describe Chef::Knife::Ec2ServerCreate do
     it "configures the bootstrap to use the EC2 server id if no explicit node name is set" do
       @knife_ec2_create.config[:chef_node_name] = nil
 
-      bootstrap = @knife_ec2_create.bootstrap_for_node(@new_ec2_server, @new_ec2_server.dns_name)
+      bootstrap = @knife_ec2_create.bootstrap_for_linux_node(@new_ec2_server, @new_ec2_server.dns_name)
       bootstrap.config[:chef_node_name].should == @new_ec2_server.id
     end
 
@@ -215,7 +352,7 @@ describe Chef::Knife::Ec2ServerCreate do
 
       @knife_ec2_create.config[:prerelease] = true
 
-      bootstrap = @knife_ec2_create.bootstrap_for_node(@new_ec2_server, @new_ec2_server.dns_name)
+      bootstrap = @knife_ec2_create.bootstrap_for_linux_node(@new_ec2_server, @new_ec2_server.dns_name)
       bootstrap.config[:prerelease].should be_true
     end
 
@@ -235,11 +372,75 @@ describe Chef::Knife::Ec2ServerCreate do
       Chef::Config[:knife][:hints]["ec2"].should_not be_nil
     end
   end
+  describe "when configuring the winrm bootstrap process for windows" do
+    before do
+      @knife_ec2_create.stub(:fetch_server_fqdn).and_return("SERVERNAME")
+      @knife_ec2_create.config[:winrm_user] = "Administrator"
+      @knife_ec2_create.config[:winrm_password] = "password"
+      @knife_ec2_create.config[:winrm_port] = 12345
+      @knife_ec2_create.config[:winrm_transport] = 'ssl'
+      @knife_ec2_create.config[:kerberos_realm] = "realm"
+      @knife_ec2_create.config[:bootstrap_protocol] = 'winrm'
+      @knife_ec2_create.config[:kerberos_service] = "service"
+      @knife_ec2_create.config[:chef_node_name] = "blarf"
+      @knife_ec2_create.config[:template_file] = '~/.chef/templates/my-bootstrap.sh.erb'
+      @knife_ec2_create.config[:distro] = 'ubuntu-10.04-magic-sparkles'
+      @knife_ec2_create.config[:run_list] = ['role[base]']
+      @knife_ec2_create.config[:json_attributes] = "{'my_attributes':{'foo':'bar'}"
+      @bootstrap = @knife_ec2_create.bootstrap_for_windows_node(@new_ec2_server, @new_ec2_server.dns_name)
+   end
+
+    include_examples "generic bootstrap configurations" do
+      subject { @knife_ec2_create }
+      let(:bootstrap) { @knife_ec2_create.bootstrap_for_linux_node(@new_ec2_server, @new_ec2_server.dns_name) }
+    end
+
+    it "should set the winrm username correctly" do
+      @bootstrap.config[:winrm_user].should == @knife_ec2_create.config[:winrm_user]
+    end
+    it "should set the winrm password correctly" do
+      @bootstrap.config[:winrm_password].should == @knife_ec2_create.config[:winrm_password]
+    end
+
+    it "should set the winrm port correctly" do
+      @bootstrap.config[:winrm_port].should == @knife_ec2_create.config[:winrm_port]
+    end
+
+    it "should set the winrm transport layer correctly" do
+      @bootstrap.config[:winrm_transport].should == @knife_ec2_create.config[:winrm_transport]
+    end
+
+    it "should set the kerberos realm correctly" do
+      @bootstrap.config[:kerberos_realm].should == @knife_ec2_create.config[:kerberos_realm]
+    end
+
+    it "should set the kerberos service correctly" do
+      @bootstrap.config[:kerberos_service].should == @knife_ec2_create.config[:kerberos_service]
+    end
+
+    it "should set the bootstrap 'name argument' to the Windows/AD hostname of the EC2 server" do
+      @bootstrap.name_args.should == ["SERVERNAME"]
+    end
+
+    it "should set the bootstrap 'name argument' to the hostname of the EC2 server when AD/Kerberos is not used" do
+      @knife_ec2_create.config[:kerberos_realm] = nil
+      @bootstrap = @knife_ec2_create.bootstrap_for_windows_node(@new_ec2_server, @new_ec2_server.dns_name)
+      @bootstrap.name_args.should == ['ec2-75.101.253.10.compute-1.amazonaws.com']
+    end
+
+    it "should set the bootstrap 'first_boot_attributes' correctly" do
+      @bootstrap.config[:first_boot_attributes].should == "{'my_attributes':{'foo':'bar'}"
+    end
+
+    it "configures sets the bootstrap's run_list" do
+      @bootstrap.config[:run_list].should == ['role[base]']
+    end
+ end
 
   describe "when validating the command-line parameters" do
     before do
       Fog::Compute::AWS.stub(:new).and_return(@ec2_connection)
-      @knife_ec2_create.ui.stub!(:error)
+      @knife_ec2_create.ui.stub(:error)
     end
 
     it "disallows security group names when using a VPC" do
@@ -255,6 +456,13 @@ describe Chef::Knife::Ec2ServerCreate do
 
       lambda { @knife_ec2_create.validate! }.should raise_error SystemExit
     end
+
+    it "disallows specifying credentials file and aws keys" do
+      Chef::Config[:knife][:aws_credential_file] = '/apple/pear'
+      File.stub(:read).and_return("AWSAccessKeyId=b\nAWSSecretKey=a")
+
+      lambda { @knife_ec2_create.validate! }.should raise_error SystemExit
+    end
   end
 
   describe "when creating the server definition" do
@@ -262,6 +470,13 @@ describe Chef::Knife::Ec2ServerCreate do
       Fog::Compute::AWS.stub(:new).and_return(@ec2_connection)
     end
 
+    it "sets the specified placement_group" do
+      @knife_ec2_create.config[:placement_group] = ['some_placement_group']
+      server_def = @knife_ec2_create.create_server_def
+
+      server_def[:placement_group].should == ['some_placement_group']
+    end
+
     it "sets the specified security group names" do
       @knife_ec2_create.config[:security_groups] = ['groupname']
       server_def = @knife_ec2_create.create_server_def
@@ -318,16 +533,29 @@ describe Chef::Knife::Ec2ServerCreate do
       server_def[:subnet_id].should == 'subnet-1a2b3c4d'
       server_def[:private_ip_address].should == '10.0.0.10'
     end
+
+    it "sets the IAM server role when one is specified" do
+      @knife_ec2_create.config[:iam_instance_profile] = ['iam-role']
+      server_def = @knife_ec2_create.create_server_def
+
+      server_def[:iam_instance_profile_name].should == ['iam-role']
+    end
+
+    it "doesn't set an IAM server role by default" do
+      server_def = @knife_ec2_create.create_server_def
+
+      server_def[:iam_instance_profile_name].should == nil
+    end
   end
 
   describe "ssh_connect_host" do
     before(:each) do
-      @new_ec2_server.stub!(
+      @new_ec2_server.stub(
         :dns_name => 'public_name',
         :private_ip_address => 'private_ip',
         :custom => 'custom'
       )
-      @knife_ec2_create.stub!(:server => @new_ec2_server)
+      @knife_ec2_create.stub(:server => @new_ec2_server)
     end
 
     describe "by default" do
@@ -338,7 +566,7 @@ describe Chef::Knife::Ec2ServerCreate do
 
     describe "with vpc_mode?" do
       it 'should use private ip' do
-        @knife_ec2_create.stub!(:vpc_mode? => true)
+        @knife_ec2_create.stub(:vpc_mode? => true)
         @knife_ec2_create.ssh_connect_host.should == 'private_ip'
       end