knife-ec2 0.18.2 → 0.19.10

data/lib/chef/knife/ec2_server_delete.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Seth Chisamore (<schisamo@chef.io>)
-# Copyright:: Copyright (c) 2009-2015 Chef Software, Inc.
+# Copyright:: Copyright (c) 2009-2018 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,11 +17,7 @@
 # limitations under the License.
 #
 
-require 'chef/knife/ec2_base'
-
-# These two are needed for the '--purge' deletion case
-require 'chef/node'
-require 'chef/api_client'
+require "chef/knife/ec2_base"
 
 class Chef
   class Knife
@@ -29,21 +25,27 @@ class Chef
 
       include Knife::Ec2Base
 
+      deps do
+        # These two are needed for the '--purge' deletion case
+        require "chef/node"
+        require "chef/api_client"
+      end
+
       banner "knife ec2 server delete SERVER [SERVER] (options)"
 
       attr_reader :server
 
       option :purge,
-        :short => "-P",
-        :long => "--purge",
-        :boolean => true,
-        :default => false,
-        :description => "Destroy corresponding node and client on the Chef Server, in addition to destroying the EC2 node itself.  Assumes node and client have the same name as the server (if not, add the '--node-name' option)."
+        short: "-P",
+        long: "--purge",
+        boolean: true,
+        default: false,
+        description: "Destroy corresponding node and client on the Chef Server, in addition to destroying the EC2 node itself.  Assumes node and client have the same name as the server (if not, add the '--node-name' option)."
 
       option :chef_node_name,
-        :short => "-N NAME",
-        :long => "--node-name NAME",
-        :description => "The name of the node and client to delete, if it differs from the server name.  Only has meaning when used with the '--purge' option."
+        short: "-N NAME",
+        long: "--node-name NAME",
+        description: "The name of the node and client to delete, if it differs from the server name.  Only has meaning when used with the '--purge' option."
 
       # Extracted from Chef::Knife.delete_object, because it has a
       # confirmation step built in... By specifying the '--purge'
@@ -51,17 +53,14 @@ class Chef
       # the user is already making their intent known.  It is not
       # necessary to make them confirm two more times.
       def destroy_item(klass, name, type_name)
-        begin
-          object = klass.load(name)
-          object.destroy
-          ui.warn("Deleted #{type_name} #{name}")
-        rescue Net::HTTPServerException
-          ui.warn("Could not find a #{type_name} named #{name} to delete!")
-        end
+        object = klass.load(name)
+        object.destroy
+        ui.warn("Deleted #{type_name} #{name}")
+      rescue Net::HTTPServerException
+        ui.warn("Could not find a #{type_name} named #{name} to delete!")
       end
 
       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")
@@ -74,23 +73,23 @@ class Chef
           begin
             @server = connection.servers.get(instance_id)
 
-            msg_pair('Instance ID', @server.id)
-            msg_pair('Instance Name', @server.tags['Name'])
-            msg_pair('Flavor', @server.flavor_id)
-            msg_pair('Image', @server.image_id)
-            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)
-            msg_pair('Public IP Address', @server.public_ip_address)
-            msg_pair('Private DNS Name', @server.private_dns_name)
-            msg_pair('Private IP Address', @server.private_ip_address)
+            msg_pair("Instance ID", @server.id)
+            msg_pair("Instance Name", @server.tags["Name"])
+            msg_pair("Flavor", @server.flavor_id)
+            msg_pair("Image", @server.image_id)
+            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)
+            msg_pair("Public IP Address", @server.public_ip_address)
+            msg_pair("Private DNS Name", @server.private_dns_name)
+            msg_pair("Private IP Address", @server.private_ip_address)
 
             puts '\n'
-            confirm('Do you really want to delete this server')
+            confirm("Do you really want to delete this server")
 
             @server.destroy
 
@@ -113,8 +112,9 @@ class Chef
         end
       end
 
+      # @return [String]
       def fetch_node_name(instance_id)
-        result = query.search(:node,"ec2_instance_id:#{instance_id}")
+        result = query.search(:node, "ec2_instance_id:#{instance_id}")
         unless result.first.empty?
           result.first.first.name
         else
@@ -122,16 +122,18 @@ class Chef
         end
       end
 
+      # @return [String]
       def fetch_instance_id(name)
-        result = query.search(:node,"name:#{name}")
+        result = query.search(:node, "name:#{name}")
         unless result.first.empty?
           node = result.first.first
-          if node.attribute?('ec2')
-            node['ec2']['instance_id']
+          if node.attribute?("ec2")
+            node["ec2"]["instance_id"]
           end
         end
       end
 
+      # @return [Chef::Search::Query]
       def query
         @query ||= Chef::Search::Query.new
       end

data/lib/chef/knife/ec2_server_list.rb

@@ -1,7 +1,7 @@
 #
 # Author:: Adam Jacob (<adam@chef.io>)
 # Author:: Seth Chisamore (<schisamo@chef.io>)
-# Copyright:: Copyright (c) 2010-2015 Chef Software, Inc.
+# Copyright:: Copyright (c) 2010-2018 Chef Software, Inc.
 # License:: Apache License, Version 2.0
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -17,7 +17,7 @@
 # limitations under the License.
 #
 
-require 'chef/knife/ec2_base'
+require "chef/knife/ec2_base"
 
 class Chef
   class Knife
@@ -28,24 +28,25 @@ class Chef
       banner "knife ec2 server list (options)"
 
       option :name,
-        :short => "-n",
-        :long => "--no-name",
-        :boolean => true,
-        :default => true,
-        :description => "Do not display name tag in output"
+        short: "-n",
+        long: "--no-name",
+        boolean: true,
+        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"
+        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"
+        short: "-t TAG1,TAG2",
+        long: "--tags TAG1,TAG2",
+        description: "List of tags to output"
 
+      # @return [Symbol]
       def azcolor(az)
         case az
         when /a$/
@@ -56,6 +57,8 @@ class Chef
           color = :red
         when /d$/
           color = :magenta
+        when /e$/
+          color = :yellow
         else
           color = :cyan
         end
@@ -67,23 +70,23 @@ class Chef
         validate!
 
         server_list = [
-          ui.color('Instance ID', :bold),
+          ui.color("Instance ID", :bold),
 
           if config[:name]
             ui.color("Name", :bold)
           end,
 
-          ui.color('Public IP', :bold),
-          ui.color('Private IP', :bold),
-          ui.color('Flavor', :bold),
+          ui.color("Public IP", :bold),
+          ui.color("Private IP", :bold),
+          ui.color("Flavor", :bold),
 
           if config[:az]
-            ui.color('AZ', :bold)
+            ui.color("AZ", :bold)
           end,
 
-          ui.color('Image', :bold),
-          ui.color('SSH Key', :bold),
-          ui.color('Security Groups', :bold),
+          ui.color("Image", :bold),
+          ui.color("SSH Key", :bold),
+          ui.color("Security Groups", :bold),
 
           if config[:tags]
             config[:tags].split(",").collect do |tag_name|
@@ -91,8 +94,8 @@ class Chef
             end
           end,
 
-          ui.color('IAM Profile', :bold),
-          ui.color('State', :bold)
+          ui.color("IAM Profile", :bold),
+          ui.color("State", :bold)
         ].flatten.compact
 
         output_column_count = server_list.length
@@ -102,7 +105,7 @@ class Chef
         end
 
         servers = connection.servers
-        if (config[:format] == 'summary')
+        if config[:format] == "summary"
           servers.each do |server|
             server_list << server.id.to_s
 
@@ -136,9 +139,9 @@ class Chef
             server_list << begin
               state = server.state.to_s.downcase
               case state
-              when 'shutting-down','terminated','stopping','stopped'
+              when "shutting-down", "terminated", "stopping", "stopped"
                 ui.color(state, :red)
-              when 'pending'
+              when "pending"
                 ui.color(state, :yellow)
               else
                 ui.color(state, :green)

data/lib/chef/knife/s3_source.rb

@@ -1,3 +1,19 @@
+#
+# 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.
+#
+
 class Chef
   class Knife
     class S3Source
@@ -19,6 +35,7 @@ class Chef
         @bucket_obj ||= fog.directories.get(bucket)
       end
 
+      # @return [URI]
       def bucket
         uri = URI(@url)
         if uri.scheme == "s3"
@@ -28,17 +45,19 @@ class Chef
         end
       end
 
+      # @return [URI]
       def path
         uri = URI(@url)
         if uri.scheme == "s3"
-          URI(@url).path.sub(/^\//, '')
+          URI(@url).path.sub(/^\//, "")
         else
-          URI(@url).path.split(bucket).last.sub(/^\//, '')
+          URI(@url).path.split(bucket).last.sub(/^\//, "")
         end
       end
 
+      # @return [Fog::Storage::AWS]
       def fog
-        require 'fog/aws' # lazy load the fog library to speed up the knife run
+        require "fog/aws" # lazy load the fog library to speed up the knife run
         @fog ||= Fog::Storage::AWS.new(
           aws_access_key_id: Chef::Config[:knife][:aws_access_key_id],
           aws_secret_access_key: Chef::Config[:knife][:aws_secret_access_key]

data/lib/knife-ec2/version.rb

@@ -1,6 +1,6 @@
 module Knife
   module Ec2
-    VERSION = "0.18.2"
-    MAJOR, MINOR, TINY = VERSION.split('.')
+    VERSION = "0.19.10".freeze
+    MAJOR, MINOR, TINY = VERSION.split(".")
   end
 end

data/spec/spec_helper.rb

@@ -1,20 +1,19 @@
-$:.unshift File.expand_path('../../lib', __FILE__)
-require 'chef'
-require 'chef/knife/winrm_base'
-require 'chef/knife/ec2_server_create'
-require 'chef/knife/ec2_server_delete'
-require 'chef/knife/ec2_server_list'
-require 'chef/knife/ec2_ami_list'
-require 'chef/knife/ec2_flavor_list'
+$:.unshift File.expand_path("../../lib", __FILE__)
+require "chef"
+require "chef/knife/winrm_base"
+require "chef/knife/ec2_server_create"
+require "chef/knife/ec2_server_delete"
+require "chef/knife/ec2_server_list"
+require "chef/knife/ec2_ami_list"
+require "chef/knife/ec2_flavor_list"
 
 # Clear config between each example
 # to avoid dependencies between examples
 RSpec.configure do |c|
   c.raise_errors_for_deprecations!
-  c.filter_run_excluding :exclude => true
+  c.filter_run_excluding exclude: true
   c.before(:each) do
     Chef::Config.reset
-    Chef::Config[:knife] ={}
+    Chef::Config[:knife] = {}
   end
 end
-

data/spec/unit/ec2_ami_list_spec.rb

@@ -13,345 +13,345 @@
   # limitations under the License.
   #
 
-  require File.expand_path('../../spec_helper', __FILE__)
-  require 'fog/aws'
+require File.expand_path("../../spec_helper", __FILE__)
+require "fog/aws"
 
-  describe Chef::Knife::Ec2AmiList do
+describe Chef::Knife::Ec2AmiList do
 
-    describe '#run' do
-      let(:knife_ec2_ami_list) { Chef::Knife::Ec2AmiList.new }
-      let(:ec2_connection) { double(Fog::Compute::AWS) }
-      before (:each) do
-        allow(knife_ec2_ami_list).to receive(:connection).and_return(ec2_connection)
-        @describe_images_format = double("describe_image_output", :body => { 
-              'imagesSet'    => [{
-              'architecture'        => "x86_64",
-              'blockDeviceMapping'  => [{"deviceName"=>"/dev/sda1",
-                                         "snapshotId"=>"snap-f7e645f4",
-                                         "volumeSize"=>30,
-                                         "deleteOnTermination"=>"true",
-                                         "volumeType"=>"standard",
-                                         "encrypted"=>"false"}],
-              'description'         => "window winrm",
-              'hypervisor'          => "xen",
-              'imageId'             => "ami-4ace6d23",
-              'imageLocation'       => "microsoft/Windows_Server-2008-R2-SP1-English-64Bit-WebMatrix_Hosting-2012.06.12",
-              'imageOwnerAlias'     => "microsoft",
-              'name'                => "Windows_Server-2008-R2-SP1-English-64Bit-Windows_Media_Services_4.1-2012.06.12",
-              'imageOwnerId'        => "461346954234",
-              'imageState'          => "available",
-              'imageType'           => "machine",
-              'isPublic'            => true,
-              'platform'            => "windows",
-              'productCodes'        => [],
-              'rootDeviceName'      => "/dev/sda1",
-              'rootDeviceType'      => "ebs",
-              'stateReason'         => {},
-              'tagSet'              => {},
-              'virtualizationType'  => "hvm"
-            }, {
-              'architecture'        => "i386",
-              'blockDeviceMapping'  => [{"deviceName"=>"/dev/sda1",
-                                         "snapshotId"=>"snap-f7e645f4",
-                                         "volumeSize"=>10,
-                                         "deleteOnTermination"=>"true",
-                                         "volumeType"=>"standard",
-                                         "encrypted"=>"false"}],
-              'description'         => "DC for Quan",
-              'hypervisor'          => "xen",
-              'imageId'             => "ami-4ace6d21",
-              'imageOwnerAlias'     => "aws-marketplace",
-              'name'                => "ubuntu i386",
-              'imageOwnerId'        => "461346954235",
-              'imageState'          => "available",
-              'imageType'           => "machine",
-              'isPublic'            => true,
-              'productCodes'        => [],
-              'rootDeviceName'      => "/dev/sda1",
-              'rootDeviceType'      => "ebs",
-              'stateReason'         => {},
-              'tagSet'              => {},
-              'virtualizationType'  => "hvm"
-            }, {
-              'architecture'        => "x86_64",
-              'blockDeviceMapping'  => [{"deviceName"=>"/dev/sda1",
-                                         "snapshotId"=>"snap-f7e645f4",
-                                         "volumeSize"=>8,
-                                         "deleteOnTermination"=>"true",
-                                         "volumeType"=>"standard",
-                                         "encrypted"=>"false"}],
-              'description'         => "ubuntu 14.04",
-              'hypervisor'          => "xen",
-              'imageId'             => "ami-4ace6d29",
-              'imageOwnerAlias'     => "aws-marketplace",
-              'name'                => "fedora i64",
-              'imageOwnerId'        => "461346954234",
-              'imageState'          => "available",
-              'imageType'           => "machine",
-              'isPublic'            => true,
-              'productCodes'        => [],
-              'rootDeviceName'      => "/dev/sda1",
-              'rootDeviceType'      => "ebs",
-              'stateReason'         => {},
-              'tagSet'              => {},
-              'virtualizationType'  => "hvm"
-            }],
-          'requestId'     => "ba38c315-f1b4-4822-b336-6309bed6d50c"
-          }
-        )
-      end
+  describe "#run" do
+    let(:knife_ec2_ami_list) { Chef::Knife::Ec2AmiList.new }
+    let(:ec2_connection) { double(Fog::Compute::AWS) }
+    before (:each) do
+      allow(knife_ec2_ami_list).to receive(:connection).and_return(ec2_connection)
+      @describe_images_format = double("describe_image_output", body: {
+            "imagesSet" => [{
+            "architecture"        => "x86_64",
+            "blockDeviceMapping"  => [{ "deviceName" => "/dev/sda1",
+                                        "snapshotId" => "snap-f7e645f4",
+                                        "volumeSize" => 30,
+                                        "deleteOnTermination" => "true",
+                                        "volumeType" => "standard",
+                                        "encrypted" => "false" }],
+            "description"         => "window winrm",
+            "hypervisor"          => "xen",
+            "imageId"             => "ami-4ace6d23",
+            "imageLocation"       => "microsoft/Windows_Server-2008-R2-SP1-English-64Bit-WebMatrix_Hosting-2012.06.12",
+            "imageOwnerAlias"     => "microsoft",
+            "name"                => "Windows_Server-2008-R2-SP1-English-64Bit-Windows_Media_Services_4.1-2012.06.12",
+            "imageOwnerId"        => "461346954234",
+            "imageState"          => "available",
+            "imageType"           => "machine",
+            "isPublic"            => true,
+            "platform"            => "windows",
+            "productCodes"        => [],
+            "rootDeviceName"      => "/dev/sda1",
+            "rootDeviceType"      => "ebs",
+            "stateReason"         => {},
+            "tagSet"              => {},
+            "virtualizationType"  => "hvm",
+          }, {
+            "architecture"        => "i386",
+            "blockDeviceMapping"  => [{ "deviceName" => "/dev/sda1",
+                                        "snapshotId" => "snap-f7e645f4",
+                                        "volumeSize" => 10,
+                                        "deleteOnTermination" => "true",
+                                        "volumeType" => "standard",
+                                        "encrypted" => "false" }],
+            "description"         => "DC for Quan",
+            "hypervisor"          => "xen",
+            "imageId"             => "ami-4ace6d21",
+            "imageOwnerAlias"     => "aws-marketplace",
+            "name"                => "ubuntu i386",
+            "imageOwnerId"        => "461346954235",
+            "imageState"          => "available",
+            "imageType"           => "machine",
+            "isPublic"            => true,
+            "productCodes"        => [],
+            "rootDeviceName"      => "/dev/sda1",
+            "rootDeviceType"      => "ebs",
+            "stateReason"         => {},
+            "tagSet"              => {},
+            "virtualizationType"  => "hvm",
+          }, {
+            "architecture"        => "x86_64",
+            "blockDeviceMapping"  => [{ "deviceName" => "/dev/sda1",
+                                        "snapshotId" => "snap-f7e645f4",
+                                        "volumeSize" => 8,
+                                        "deleteOnTermination" => "true",
+                                        "volumeType" => "standard",
+                                        "encrypted" => "false" }],
+            "description"         => "ubuntu 14.04",
+            "hypervisor"          => "xen",
+            "imageId"             => "ami-4ace6d29",
+            "imageOwnerAlias"     => "aws-marketplace",
+            "name"                => "fedora i64",
+            "imageOwnerId"        => "461346954234",
+            "imageState"          => "available",
+            "imageType"           => "machine",
+            "isPublic"            => true,
+            "productCodes"        => [],
+            "rootDeviceName"      => "/dev/sda1",
+            "rootDeviceType"      => "ebs",
+            "stateReason"         => {},
+            "tagSet"              => {},
+            "virtualizationType"  => "hvm",
+          }],
+            "requestId" => "ba38c315-f1b4-4822-b336-6309bed6d50c",
+        }
+      )
+    end
 
-      it 'invokes validate!' do
+    it "invokes validate!" do
+      allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+      allow(knife_ec2_ami_list.ui).to receive(:warn)
+      expect(knife_ec2_ami_list).to receive(:validate!)
+      knife_ec2_ami_list.run
+    end
+
+    context "when region is not specified" do
+      it "shows warning that default region will be will be used" do
+        knife_ec2_ami_list.config.delete(:region)
+        Chef::Config[:knife].delete(:region)
+        ec2_servers = double()
         allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-        allow(knife_ec2_ami_list.ui).to receive(:warn)
-        expect(knife_ec2_ami_list).to receive(:validate!)
+        allow(knife_ec2_ami_list).to receive(:validate!)
+        expect(knife_ec2_ami_list.ui).to receive(:warn).with("No region was specified in knife.rb or as an argument. The default region, us-east-1, will be used:")
         knife_ec2_ami_list.run
       end
+    end
 
-      context 'when region is not specified' do
-        it 'shows warning that default region will be will be used' do
-          knife_ec2_ami_list.config.delete(:region)
-          Chef::Config[:knife].delete(:region)
-          ec2_servers = double()
-          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-          allow(knife_ec2_ami_list).to receive(:validate!)
-          expect(knife_ec2_ami_list.ui).to receive(:warn).with("No region was specified in knife.rb or as an argument. The default region, us-east-1, will be used:")
-          knife_ec2_ami_list.run
-        end
+    context "when --owner is passed" do
+      before do
+        allow(knife_ec2_ami_list.ui).to receive(:warn)
+        allow(knife_ec2_ami_list).to receive(:custom_warnings!)
+        knife_ec2_ami_list.config[:use_iam_profile] = true
       end
 
-      context 'when --owner is passed' do
-        before do
-          allow(knife_ec2_ami_list.ui).to receive(:warn)
-          allow(knife_ec2_ami_list).to receive(:custom_warnings!)
-          knife_ec2_ami_list.config[:use_iam_profile] = true
-        end
-
-        context 'When value for owner is nil' do
-          it 'shows the available AMIs List' do
-            knife_ec2_ami_list.config[:owner] = nil
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            expect(knife_ec2_ami_list).to receive(:validate!)
-            images = ec2_connection.describe_images.body['imagesSet']
-            output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
-            output_column_count = output_column.length
-            images.each do |image|
-              output_column << image["imageId"].to_s
-              output_column << (image["platform"] ?  image["platform"] : image["name"].split(/\W+/).first)
-              output_column << image["architecture"].to_s
-              output_column << image["blockDeviceMapping"].first["volumeSize"].to_s
-              output_column << image["name"].split(/\W+/).first
-              output_column << image["description"]
-            end
-            expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
-            knife_ec2_ami_list.run
+      context "When value for owner is nil" do
+        it "shows the available AMIs List" do
+          knife_ec2_ami_list.config[:owner] = nil
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          expect(knife_ec2_ami_list).to receive(:validate!)
+          images = ec2_connection.describe_images.body["imagesSet"]
+          output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
+          output_column_count = output_column.length
+          images.each do |image|
+            output_column << image["imageId"].to_s
+            output_column << (image["platform"] ? image["platform"] : image["name"].split(/\W+/).first)
+            output_column << image["architecture"].to_s
+            output_column << image["blockDeviceMapping"].first["volumeSize"].to_s
+            output_column << image["name"].split(/\W+/).first
+            output_column << image["description"]
           end
+          expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column, :uneven_columns_across, output_column_count)
+          knife_ec2_ami_list.run
         end
+      end
 
-        context 'When value for owner is self' do
-          it 'does not raise any error' do
-            knife_ec2_ami_list.config[:owner] = 'self'
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            expect{ knife_ec2_ami_list.validate! }.not_to raise_error
-          end
+      context "When value for owner is self" do
+        it "does not raise any error" do
+          knife_ec2_ami_list.config[:owner] = "self"
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          expect { knife_ec2_ami_list.validate! }.not_to raise_error
         end
+      end
 
-        context 'When value for owner is microsoft' do
-          it 'does not raise any error' do
-            knife_ec2_ami_list.config[:owner] = 'microsoft'
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            expect{ knife_ec2_ami_list.validate! }.not_to raise_error
-          end
+      context "When value for owner is microsoft" do
+        it "does not raise any error" do
+          knife_ec2_ami_list.config[:owner] = "microsoft"
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          expect { knife_ec2_ami_list.validate! }.not_to raise_error
         end
+      end
 
-        context 'When value for owner is aws-marketplace' do
-          it 'does not raise any error' do
-            knife_ec2_ami_list.config[:owner] = 'aws-marketplace'
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            expect{ knife_ec2_ami_list.validate! }.not_to raise_error
-          end
+      context "When value for owner is aws-marketplace" do
+        it "does not raise any error" do
+          knife_ec2_ami_list.config[:owner] = "aws-marketplace"
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          expect { knife_ec2_ami_list.validate! }.not_to raise_error
         end
+      end
 
-        context 'When owner is invalid' do
-          it 'raises error' do
-            knife_ec2_ami_list.config[:owner] = 'xyz'
-            knife_ec2_ami_list.config[:use_iam_profile] = true
-            expect{ knife_ec2_ami_list.validate! }.to raise_error "Invalid owner: #{knife_ec2_ami_list.config[:owner]}. Allowed owners are self, aws-marketplace or microsoft."
-          end
+      context "When owner is invalid" do
+        it "raises error" do
+          knife_ec2_ami_list.config[:owner] = "xyz"
+          knife_ec2_ami_list.config[:use_iam_profile] = true
+          expect { knife_ec2_ami_list.validate! }.to raise_error "Invalid owner: #{knife_ec2_ami_list.config[:owner]}. Allowed owners are self, aws-marketplace or microsoft."
         end
       end
+    end
 
-      context 'when --platform is passed' do
-        before do
-          allow(knife_ec2_ami_list.ui).to receive(:warn)
-          allow(knife_ec2_ami_list).to receive(:custom_warnings!)
-        end
+    context "when --platform is passed" do
+      before do
+        allow(knife_ec2_ami_list.ui).to receive(:warn)
+        allow(knife_ec2_ami_list).to receive(:custom_warnings!)
+      end
 
-        context 'When platform is nil' do
-          it 'shows all the AMIs List' do
-            knife_ec2_ami_list.config[:platform] = nil
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            images = ec2_connection.describe_images.body['imagesSet']
-            expect(knife_ec2_ami_list).to receive(:validate!)
-            output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
-            output_column_count = output_column.length
-            images.each do |image|
-              output_column << image["imageId"].to_s
-              output_column << (image["platform"] ?  image["platform"] : image["name"].split(/\W+/).first)
-              output_column << image["architecture"].to_s
-              output_column << image["blockDeviceMapping"].first["volumeSize"].to_s
-              output_column << image["name"].split(/\W+/).first
-              output_column << image["description"]
-            end
-            expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
-            knife_ec2_ami_list.run
+      context "When platform is nil" do
+        it "shows all the AMIs List" do
+          knife_ec2_ami_list.config[:platform] = nil
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          images = ec2_connection.describe_images.body["imagesSet"]
+          expect(knife_ec2_ami_list).to receive(:validate!)
+          output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
+          output_column_count = output_column.length
+          images.each do |image|
+            output_column << image["imageId"].to_s
+            output_column << (image["platform"] ? image["platform"] : image["name"].split(/\W+/).first)
+            output_column << image["architecture"].to_s
+            output_column << image["blockDeviceMapping"].first["volumeSize"].to_s
+            output_column << image["name"].split(/\W+/).first
+            output_column << image["description"]
           end
+          expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column, :uneven_columns_across, output_column_count)
+          knife_ec2_ami_list.run
         end
+      end
 
-        context 'When platform is windows' do
-          it 'shows only windows AMIs List' do
-            knife_ec2_ami_list.config[:platform] = 'windows'
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            window_image = ec2_connection.describe_images.body['imagesSet'].first
-            expect(knife_ec2_ami_list).to receive(:validate!)
-            output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
-            output_column_count = output_column.length
-            output_column << window_image["imageId"]
-            output_column << window_image["platform"]
-            output_column << window_image["architecture"]
-            output_column << window_image["blockDeviceMapping"].first["volumeSize"].to_s
-            output_column << window_image["name"].split(/\W+/).first
-            output_column << window_image["description"]
-            expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
-            knife_ec2_ami_list.run
-          end
+      context "When platform is windows" do
+        it "shows only windows AMIs List" do
+          knife_ec2_ami_list.config[:platform] = "windows"
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          window_image = ec2_connection.describe_images.body["imagesSet"].first
+          expect(knife_ec2_ami_list).to receive(:validate!)
+          output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
+          output_column_count = output_column.length
+          output_column << window_image["imageId"]
+          output_column << window_image["platform"]
+          output_column << window_image["architecture"]
+          output_column << window_image["blockDeviceMapping"].first["volumeSize"].to_s
+          output_column << window_image["name"].split(/\W+/).first
+          output_column << window_image["description"]
+          expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column, :uneven_columns_across, output_column_count)
+          knife_ec2_ami_list.run
         end
+      end
 
-        context 'When platform is ubuntu' do
-          it 'shows only ubuntu AMIs List' do
-            knife_ec2_ami_list.config[:platform] = 'ubuntu'
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            ubuntu_image = ec2_connection.describe_images.body['imagesSet'][1]
-            expect(knife_ec2_ami_list).to receive(:validate!)
-            output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
-            output_column_count = output_column.length
-            output_column << ubuntu_image["imageId"]
-            output_column << ubuntu_image["name"].split(/\W+/).first
-            output_column << ubuntu_image["architecture"]
-            output_column << ubuntu_image["blockDeviceMapping"].first["volumeSize"].to_s
-            output_column << ubuntu_image["name"].split(/\W+/).first
-            output_column << ubuntu_image["description"]
-            expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
-            knife_ec2_ami_list.run
-          end
+      context "When platform is ubuntu" do
+        it "shows only ubuntu AMIs List" do
+          knife_ec2_ami_list.config[:platform] = "ubuntu"
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          ubuntu_image = ec2_connection.describe_images.body["imagesSet"][1]
+          expect(knife_ec2_ami_list).to receive(:validate!)
+          output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
+          output_column_count = output_column.length
+          output_column << ubuntu_image["imageId"]
+          output_column << ubuntu_image["name"].split(/\W+/).first
+          output_column << ubuntu_image["architecture"]
+          output_column << ubuntu_image["blockDeviceMapping"].first["volumeSize"].to_s
+          output_column << ubuntu_image["name"].split(/\W+/).first
+          output_column << ubuntu_image["description"]
+          expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column, :uneven_columns_across, output_column_count)
+          knife_ec2_ami_list.run
         end
+      end
 
-        context 'When platform is fedora' do
-          it 'shows only fedora AMIs List' do
-            knife_ec2_ami_list.config[:platform] = 'fedora'
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            expect(knife_ec2_ami_list).to receive(:validate!)
-            fedora_image = ec2_connection.describe_images.body['imagesSet'].last
-            output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
-            output_column_count = output_column.length
-            output_column << fedora_image["imageId"]
-            output_column << fedora_image["name"].split(/\W+/).first
-            output_column << fedora_image["architecture"]
-            output_column << fedora_image["blockDeviceMapping"].first["volumeSize"].to_s
-            output_column << fedora_image["name"].split(/\W+/).first
-            output_column << fedora_image["description"]
-            expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
-            knife_ec2_ami_list.run
-          end
+      context "When platform is fedora" do
+        it "shows only fedora AMIs List" do
+          knife_ec2_ami_list.config[:platform] = "fedora"
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          expect(knife_ec2_ami_list).to receive(:validate!)
+          fedora_image = ec2_connection.describe_images.body["imagesSet"].last
+          output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
+          output_column_count = output_column.length
+          output_column << fedora_image["imageId"]
+          output_column << fedora_image["name"].split(/\W+/).first
+          output_column << fedora_image["architecture"]
+          output_column << fedora_image["blockDeviceMapping"].first["volumeSize"].to_s
+          output_column << fedora_image["name"].split(/\W+/).first
+          output_column << fedora_image["description"]
+          expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column, :uneven_columns_across, output_column_count)
+          knife_ec2_ami_list.run
         end
+      end
 
-        context 'When platform is invalid' do
-          it 'raises error' do
-            knife_ec2_ami_list.config[:platform] = 'xyz'
-            knife_ec2_ami_list.config[:use_iam_profile] = true
-            knife_ec2_ami_list.config[:owner] = true
-            expect{ knife_ec2_ami_list.validate! }.to raise_error "Invalid platform: #{knife_ec2_ami_list.config[:platform]}. Allowed platforms are: windows, ubuntu, debian, centos, fedora, rhel, nginx, turnkey, jumpbox, coreos, cisco, amazon, nessus."
-          end
+      context "When platform is invalid" do
+        it "raises error" do
+          knife_ec2_ami_list.config[:platform] = "xyz"
+          knife_ec2_ami_list.config[:use_iam_profile] = true
+          knife_ec2_ami_list.config[:owner] = true
+          expect { knife_ec2_ami_list.validate! }.to raise_error "Invalid platform: #{knife_ec2_ami_list.config[:platform]}. Allowed platforms are: windows, ubuntu, debian, centos, fedora, rhel, nginx, turnkey, jumpbox, coreos, cisco, amazon, nessus."
         end
       end
+    end
 
-      context 'when --search is passed' do
-        before do
-          allow(knife_ec2_ami_list.ui).to receive(:warn)
-          allow(knife_ec2_ami_list).to receive(:custom_warnings!)
-        end
+    context "when --search is passed" do
+      before do
+        allow(knife_ec2_ami_list.ui).to receive(:warn)
+        allow(knife_ec2_ami_list).to receive(:custom_warnings!)
+      end
 
-        context 'When search key word is present in description' do
-          it 'shows only AMIs List that have 14.04 in description' do
-            knife_ec2_ami_list.config[:search] = '14.04'
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            image = ec2_connection.describe_images.body['imagesSet'][2]
-            expect(knife_ec2_ami_list).to receive(:validate!)
-            output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
-            output_column_count = output_column.length
-            output_column << image["imageId"]
-            output_column << image["name"].split(/\W+/).first
-            output_column << image["architecture"]
-            output_column << image["blockDeviceMapping"].first["volumeSize"].to_s
-            output_column << image["name"].split(/\W+/).first
-            output_column << image["description"]
-            expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
-            knife_ec2_ami_list.run
-          end
+      context "When search key word is present in description" do
+        it "shows only AMIs List that have 14.04 in description" do
+          knife_ec2_ami_list.config[:search] = "14.04"
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          image = ec2_connection.describe_images.body["imagesSet"][2]
+          expect(knife_ec2_ami_list).to receive(:validate!)
+          output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
+          output_column_count = output_column.length
+          output_column << image["imageId"]
+          output_column << image["name"].split(/\W+/).first
+          output_column << image["architecture"]
+          output_column << image["blockDeviceMapping"].first["volumeSize"].to_s
+          output_column << image["name"].split(/\W+/).first
+          output_column << image["description"]
+          expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column, :uneven_columns_across, output_column_count)
+          knife_ec2_ami_list.run
         end
+      end
 
-        context 'When user pass platform and search keyword' do
-          it 'shows only AMIs List that have 14.04 in description and platform is ubuntu' do
-            knife_ec2_ami_list.config[:platform] = 'ubuntu'
-            knife_ec2_ami_list.config[:search] = 'Quan'
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            ubuntu_image = ec2_connection.describe_images.body['imagesSet'][1]
-            expect(knife_ec2_ami_list).to receive(:validate!)
-            output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
-            output_column_count = output_column.length
-            output_column << ubuntu_image["imageId"]
-            output_column << ubuntu_image["name"].split(/\W+/).first
-            output_column << ubuntu_image["architecture"]
-            output_column << ubuntu_image["blockDeviceMapping"].first["volumeSize"].to_s
-            output_column << ubuntu_image["name"].split(/\W+/).first
-            output_column << ubuntu_image["description"]
-            expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
-            knife_ec2_ami_list.run
-          end
+      context "When user pass platform and search keyword" do
+        it "shows only AMIs List that have 14.04 in description and platform is ubuntu" do
+          knife_ec2_ami_list.config[:platform] = "ubuntu"
+          knife_ec2_ami_list.config[:search] = "Quan"
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          ubuntu_image = ec2_connection.describe_images.body["imagesSet"][1]
+          expect(knife_ec2_ami_list).to receive(:validate!)
+          output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
+          output_column_count = output_column.length
+          output_column << ubuntu_image["imageId"]
+          output_column << ubuntu_image["name"].split(/\W+/).first
+          output_column << ubuntu_image["architecture"]
+          output_column << ubuntu_image["blockDeviceMapping"].first["volumeSize"].to_s
+          output_column << ubuntu_image["name"].split(/\W+/).first
+          output_column << ubuntu_image["description"]
+          expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column, :uneven_columns_across, output_column_count)
+          knife_ec2_ami_list.run
         end
+      end
 
-        context 'When user pass owner, platform and search keyword' do
-          it 'shows only AMIs List that owner microsoft platform windows and search keyword is winrm' do
-            knife_ec2_ami_list.config[:owner] = 'microsoft'
-            knife_ec2_ami_list.config[:platform] = 'windows'
-            knife_ec2_ami_list.config[:search] = 'winrm'
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            ubuntu_image = ec2_connection.describe_images.body['imagesSet'].first
-            expect(knife_ec2_ami_list).to receive(:validate!)
-            output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
-            output_column_count = output_column.length
-            output_column << ubuntu_image["imageId"]
-            output_column << ubuntu_image["platform"]
-            output_column << ubuntu_image["architecture"]
-            output_column << ubuntu_image["blockDeviceMapping"].first["volumeSize"].to_s
-            output_column << ubuntu_image["name"].split(/\W+/).first
-            output_column << ubuntu_image["description"]
-            expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
-            knife_ec2_ami_list.run
-          end
+      context "When user pass owner, platform and search keyword" do
+        it "shows only AMIs List that owner microsoft platform windows and search keyword is winrm" do
+          knife_ec2_ami_list.config[:owner] = "microsoft"
+          knife_ec2_ami_list.config[:platform] = "windows"
+          knife_ec2_ami_list.config[:search] = "winrm"
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          ubuntu_image = ec2_connection.describe_images.body["imagesSet"].first
+          expect(knife_ec2_ami_list).to receive(:validate!)
+          output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
+          output_column_count = output_column.length
+          output_column << ubuntu_image["imageId"]
+          output_column << ubuntu_image["platform"]
+          output_column << ubuntu_image["architecture"]
+          output_column << ubuntu_image["blockDeviceMapping"].first["volumeSize"].to_s
+          output_column << ubuntu_image["name"].split(/\W+/).first
+          output_column << ubuntu_image["description"]
+          expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column, :uneven_columns_across, output_column_count)
+          knife_ec2_ami_list.run
         end
+      end
 
-        context 'When search key word is not present in description' do
-          it 'Fetch no AMI' do
-            knife_ec2_ami_list.config[:search] = 'Not present'
-            allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
-            expect(knife_ec2_ami_list).to receive(:validate!)
-            output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
-            output_column_count = output_column.length
-            expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
-            knife_ec2_ami_list.run
-          end
+      context "When search key word is not present in description" do
+        it "Fetch no AMI" do
+          knife_ec2_ami_list.config[:search] = "Not present"
+          allow(ec2_connection).to receive(:describe_images).and_return(@describe_images_format)
+          expect(knife_ec2_ami_list).to receive(:validate!)
+          output_column = ["AMI ID", "Platform", "Architecture", "Size", "Name", "Description"]
+          output_column_count = output_column.length
+          expect(knife_ec2_ami_list.ui).to receive(:list).with(output_column, :uneven_columns_across, output_column_count)
+          knife_ec2_ami_list.run
         end
       end
     end
   end
+end