knife-ec2 0.12.0 → 0.13.0

data/spec/unit/ec2_server_delete_spec.rb

@@ -1,141 +1,141 @@
-# 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 File.expand_path('../../spec_helper', __FILE__)
-require 'fog'
-
-
-describe Chef::Knife::Ec2ServerDelete do
-  before do
-  end
-
-  describe "run" do
-    before(:each) do
-      {
-        :image => 'image',
-        :ssh_key_name => 'ssh_key_name',
-        :aws_access_key_id => 'aws_access_key_id',
-        :aws_secret_access_key => 'aws_secret_access_key'
-      }.each do |key, value|
-        Chef::Config[:knife][key] = value
-      end
-
-      @ec2_server_attribs = { :id => 'i-39382318',
-                             :flavor_id => 'm1.small',
-                             :image_id => 'ami-47241231',
-                             :availability_zone => 'us-west-1',
-                             :key_name => 'my_ssh_key',
-                             :groups => ['group1', 'group2'],
-                             :security_group_ids => ['sg-00aa11bb'],
-                             :dns_name => 'ec2-75.101.253.10.compute-1.amazonaws.com',
-                             :iam_instance_profile => {},
-                             :public_ip_address => '75.101.253.10',
-                             :private_dns_name => 'ip-10-251-75-20.ec2.internal',
-                             :private_ip_address => '10.251.75.20',
-                             :root_device_type => 'not_ebs',
-                             :tags => {'Name' => 'foo'}
-                            }
-        @knife_ec2_delete = Chef::Knife::Ec2ServerDelete.new
-        @ec2_servers = double()
-        allow(@knife_ec2_delete.ui).to receive(:confirm)
-        allow(@knife_ec2_delete).to receive(:msg_pair)
-        @ec2_server = double(@ec2_server_attribs)
-        @ec2_connection = double(Fog::Compute::AWS)
-        allow(@ec2_connection).to receive(:servers).and_return(@ec2_servers)
-        allow(@knife_ec2_delete.ui).to receive(:warn)
-      end
-
-    it "should invoke validate!" do
-      knife_ec2_delete = Chef::Knife::Ec2ServerDelete.new
-      expect(knife_ec2_delete).to receive(:validate!)
-      knife_ec2_delete.run
-    end
-
-    it "should use invoke fog api to delete instance if instance id is passed" do
-      expect(@ec2_servers).to receive(:get).with('foo').and_return(@ec2_server)
-      expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
-      @knife_ec2_delete.name_args = ['foo']
-      expect(@knife_ec2_delete).to receive(:validate!)
-      expect(@ec2_server).to receive(:destroy)
-      @knife_ec2_delete.run
-    end
-
-    it "should use node_name to figure out instance id if not specified explicitly" do
-        expect(@ec2_servers).to receive(:get).with('foo').and_return(@ec2_server)
-        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
-        expect(@knife_ec2_delete).to receive(:validate!)
-        expect(@ec2_server).to receive(:destroy)
-        @knife_ec2_delete.config[:purge] = false
-        @knife_ec2_delete.config[:chef_node_name] = 'baz'
-        double_node = double(Chef::Node)
-        expect(double_node).to receive(:attribute?).with('ec2').and_return(true)
-        expect(double_node).to receive(:[]).with('ec2').and_return('instance_id'=>'foo')
-        double_search = double(Chef::Search::Query)
-        expect(double_search).to receive(:search).with(:node,"name:baz").and_return([[double_node],nil,nil])
-        expect(Chef::Search::Query).to receive(:new).and_return(double_search)
-        @knife_ec2_delete.name_args = []
-        @knife_ec2_delete.run
-    end
-
-    describe "when --purge is passed" do
-      it "should use the node name if its set" do
-        expect(@ec2_servers).to receive(:get).with('foo').and_return(@ec2_server)
-        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
-        @knife_ec2_delete.name_args = ['foo']
-        expect(@knife_ec2_delete).to receive(:validate!)
-        expect(@ec2_server).to receive(:destroy)
-        @knife_ec2_delete.config[:purge] = true
-        @knife_ec2_delete.config[:chef_node_name] = 'baz'
-        expect(Chef::Node).to receive(:load).with('baz').and_return(double(:destroy=>true))
-        expect(Chef::ApiClient).to receive(:load).with('baz').and_return(double(:destroy=>true))
-        @knife_ec2_delete.run
-      end
-
-      it "should search for the node name using the instance id when node name is not specified" do
-        expect(@ec2_servers).to receive(:get).with('i-foo').and_return(@ec2_server)
-        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
-        @knife_ec2_delete.name_args = ['i-foo']
-        expect(@knife_ec2_delete).to receive(:validate!)
-        expect(@ec2_server).to receive(:destroy)
-        @knife_ec2_delete.config[:purge] = true
-        @knife_ec2_delete.config[:chef_node_name] = nil
-        double_search = double(Chef::Search::Query)
-        double_node = double(Chef::Node)
-        expect(double_node).to receive(:name).and_return("baz")
-        expect(Chef::Node).to receive(:load).with('baz').and_return(double(:destroy=>true))
-        expect(Chef::ApiClient).to receive(:load).with('baz').and_return(double(:destroy=>true))
-        expect(double_search).to receive(:search).with(:node,"ec2_instance_id:i-foo").and_return([[double_node],nil,nil])
-        expect(Chef::Search::Query).to receive(:new).and_return(double_search)
-        @knife_ec2_delete.run
-      end
-
-      it "should use  the instance id if search does not return anything" do
-        expect(@ec2_servers).to receive(:get).with('i-foo').and_return(@ec2_server)
-        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
-        @knife_ec2_delete.name_args = ['i-foo']
-        expect(@knife_ec2_delete).to receive(:validate!)
-        expect(@ec2_server).to receive(:destroy)
-        @knife_ec2_delete.config[:purge] = true
-        @knife_ec2_delete.config[:chef_node_name] = nil
-        expect(Chef::Node).to receive(:load).with('i-foo').and_return(double(:destroy=>true))
-        expect(Chef::ApiClient).to receive(:load).with('i-foo').and_return(double(:destroy=>true))
-        double_search = double(Chef::Search::Query)
-        expect(double_search).to receive(:search).with(:node,"ec2_instance_id:i-foo").and_return([[],nil,nil])
-        expect(Chef::Search::Query).to receive(:new).and_return(double_search)
-        @knife_ec2_delete.run
-      end
-    end
-  end
-end
+# 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 File.expand_path('../../spec_helper', __FILE__)
+require 'fog/aws'
+
+
+describe Chef::Knife::Ec2ServerDelete do
+  before do
+  end
+
+  describe "run" do
+    before(:each) do
+      {
+        :image => 'image',
+        :ssh_key_name => 'ssh_key_name',
+        :aws_access_key_id => 'aws_access_key_id',
+        :aws_secret_access_key => 'aws_secret_access_key'
+      }.each do |key, value|
+        Chef::Config[:knife][key] = value
+      end
+
+      @ec2_server_attribs = { :id => 'i-39382318',
+                             :flavor_id => 'm1.small',
+                             :image_id => 'ami-47241231',
+                             :availability_zone => 'us-west-1',
+                             :key_name => 'my_ssh_key',
+                             :groups => ['group1', 'group2'],
+                             :security_group_ids => ['sg-00aa11bb'],
+                             :dns_name => 'ec2-75.101.253.10.compute-1.amazonaws.com',
+                             :iam_instance_profile => {},
+                             :public_ip_address => '75.101.253.10',
+                             :private_dns_name => 'ip-10-251-75-20.ec2.internal',
+                             :private_ip_address => '10.251.75.20',
+                             :root_device_type => 'not_ebs',
+                             :tags => {'Name' => 'foo'}
+                            }
+        @knife_ec2_delete = Chef::Knife::Ec2ServerDelete.new
+        @ec2_servers = double()
+        allow(@knife_ec2_delete.ui).to receive(:confirm)
+        allow(@knife_ec2_delete).to receive(:msg_pair)
+        @ec2_server = double(@ec2_server_attribs)
+        @ec2_connection = double(Fog::Compute::AWS)
+        allow(@ec2_connection).to receive(:servers).and_return(@ec2_servers)
+        allow(@knife_ec2_delete.ui).to receive(:warn)
+      end
+
+    it "should invoke validate!" do
+      knife_ec2_delete = Chef::Knife::Ec2ServerDelete.new
+      expect(knife_ec2_delete).to receive(:validate!)
+      knife_ec2_delete.run
+    end
+
+    it "should use invoke fog api to delete instance if instance id is passed" do
+      expect(@ec2_servers).to receive(:get).with('foo').and_return(@ec2_server)
+      expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
+      @knife_ec2_delete.name_args = ['foo']
+      expect(@knife_ec2_delete).to receive(:validate!)
+      expect(@ec2_server).to receive(:destroy)
+      @knife_ec2_delete.run
+    end
+
+    it "should use node_name to figure out instance id if not specified explicitly" do
+        expect(@ec2_servers).to receive(:get).with('foo').and_return(@ec2_server)
+        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
+        expect(@knife_ec2_delete).to receive(:validate!)
+        expect(@ec2_server).to receive(:destroy)
+        @knife_ec2_delete.config[:purge] = false
+        @knife_ec2_delete.config[:chef_node_name] = 'baz'
+        double_node = double(Chef::Node)
+        expect(double_node).to receive(:attribute?).with('ec2').and_return(true)
+        expect(double_node).to receive(:[]).with('ec2').and_return('instance_id'=>'foo')
+        double_search = double(Chef::Search::Query)
+        expect(double_search).to receive(:search).with(:node,"name:baz").and_return([[double_node],nil,nil])
+        expect(Chef::Search::Query).to receive(:new).and_return(double_search)
+        @knife_ec2_delete.name_args = []
+        @knife_ec2_delete.run
+    end
+
+    describe "when --purge is passed" do
+      it "should use the node name if its set" do
+        expect(@ec2_servers).to receive(:get).with('foo').and_return(@ec2_server)
+        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
+        @knife_ec2_delete.name_args = ['foo']
+        expect(@knife_ec2_delete).to receive(:validate!)
+        expect(@ec2_server).to receive(:destroy)
+        @knife_ec2_delete.config[:purge] = true
+        @knife_ec2_delete.config[:chef_node_name] = 'baz'
+        expect(Chef::Node).to receive(:load).with('baz').and_return(double(:destroy=>true))
+        expect(Chef::ApiClient).to receive(:load).with('baz').and_return(double(:destroy=>true))
+        @knife_ec2_delete.run
+      end
+
+      it "should search for the node name using the instance id when node name is not specified" do
+        expect(@ec2_servers).to receive(:get).with('i-foo').and_return(@ec2_server)
+        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
+        @knife_ec2_delete.name_args = ['i-foo']
+        expect(@knife_ec2_delete).to receive(:validate!)
+        expect(@ec2_server).to receive(:destroy)
+        @knife_ec2_delete.config[:purge] = true
+        @knife_ec2_delete.config[:chef_node_name] = nil
+        double_search = double(Chef::Search::Query)
+        double_node = double(Chef::Node)
+        expect(double_node).to receive(:name).and_return("baz")
+        expect(Chef::Node).to receive(:load).with('baz').and_return(double(:destroy=>true))
+        expect(Chef::ApiClient).to receive(:load).with('baz').and_return(double(:destroy=>true))
+        expect(double_search).to receive(:search).with(:node,"ec2_instance_id:i-foo").and_return([[double_node],nil,nil])
+        expect(Chef::Search::Query).to receive(:new).and_return(double_search)
+        @knife_ec2_delete.run
+      end
+
+      it "should use  the instance id if search does not return anything" do
+        expect(@ec2_servers).to receive(:get).with('i-foo').and_return(@ec2_server)
+        expect(Fog::Compute::AWS).to receive(:new).and_return(@ec2_connection)
+        @knife_ec2_delete.name_args = ['i-foo']
+        expect(@knife_ec2_delete).to receive(:validate!)
+        expect(@ec2_server).to receive(:destroy)
+        @knife_ec2_delete.config[:purge] = true
+        @knife_ec2_delete.config[:chef_node_name] = nil
+        expect(Chef::Node).to receive(:load).with('i-foo').and_return(double(:destroy=>true))
+        expect(Chef::ApiClient).to receive(:load).with('i-foo').and_return(double(:destroy=>true))
+        double_search = double(Chef::Search::Query)
+        expect(double_search).to receive(:search).with(:node,"ec2_instance_id:i-foo").and_return([[],nil,nil])
+        expect(Chef::Search::Query).to receive(:new).and_return(double_search)
+        @knife_ec2_delete.run
+      end
+    end
+  end
+end

data/spec/unit/ec2_server_list_spec.rb

@@ -0,0 +1,131 @@
+# 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 File.expand_path('../../spec_helper', __FILE__)
+require 'fog/aws'
+
+describe Chef::Knife::Ec2ServerList do
+
+  describe '#run' do
+    let(:knife_ec2_list) { Chef::Knife::Ec2ServerList.new }
+    let(:ec2_connection) { double(Fog::Compute::AWS) }
+    before do
+      allow(knife_ec2_list).to receive(:connection).and_return(ec2_connection)
+    end
+
+    it 'invokes validate!' do
+      ec2_servers = double()
+      allow(ec2_connection).to receive(:servers).and_return(ec2_servers)
+      allow(knife_ec2_list.ui).to receive(:warn)
+      expect(knife_ec2_list).to receive(:validate!)
+      knife_ec2_list.run
+    end
+
+    context 'when region is not specified' do
+      it 'shows warning that default region will be will be used' do
+        knife_ec2_list.config.delete(:region)
+        Chef::Config[:knife].delete(:region)
+        ec2_servers = double()
+        allow(ec2_connection).to receive(:servers).and_return(ec2_servers)
+        allow(knife_ec2_list).to receive(:validate!)
+        expect(knife_ec2_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_list.run
+      end
+    end
+
+    context '--format option' do
+      context 'when format=summary' do
+        before do
+          knife_ec2_list.config[:format] = 'summary'
+          allow(knife_ec2_list.ui).to receive(:warn)
+        end
+
+        it 'shows the output without Tags and Availability Zone in summary format' do
+          output_column = ["Instance ID", "Public IP", "Private IP", "Flavor",
+            "Image", "SSH Key", "Security Groups", "IAM Profile", "State"]
+          output_column_count = output_column.length
+          allow(ec2_connection).to receive(:servers).and_return([])
+          allow(knife_ec2_list).to receive(:validate!)
+          expect(knife_ec2_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
+          knife_ec2_list.run
+        end
+      end
+
+      context 'when format=json' do
+        before do
+          knife_ec2_list.config[:format] = 'json'
+          allow(knife_ec2_list.ui).to receive(:warn)
+        end
+
+        it 'shows the output without Tags and Availability Zone in summary format' do
+          allow(ec2_connection).to receive(:servers).and_return([])
+          allow(knife_ec2_list).to receive(:validate!)
+          allow(knife_ec2_list).to receive(:format_for_display)
+          expect(knife_ec2_list).to receive(:output)
+          knife_ec2_list.run
+        end
+      end
+    end
+
+    context 'when --tags option is passed' do
+      before do
+        knife_ec2_list.config[:format] = 'summary'
+        allow(knife_ec2_list.ui).to receive(:warn)
+        allow(ec2_connection).to receive(:servers).and_return([])
+        allow(knife_ec2_list).to receive(:validate!)
+      end
+
+      context 'when single tag is passed' do
+        it 'shows single tag field in the output' do
+          knife_ec2_list.config[:tags] = 'tag1'
+          output_column = ["Instance ID", "Public IP", "Private IP", "Flavor",
+            "Image", "SSH Key", "Security Groups", "Tag:tag1", "IAM Profile", "State"]
+          output_column_count = output_column.length
+          expect(knife_ec2_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
+          knife_ec2_list.run
+        end
+      end
+
+      context 'when multiple tags are passed' do
+        it 'shows multiple tags fields in the output' do
+          knife_ec2_list.config[:tags] = 'tag1,tag2'
+          output_column = ["Instance ID", "Public IP", "Private IP", "Flavor",
+            "Image", "SSH Key", "Security Groups", "Tag:tag1", "Tag:tag2", "IAM Profile", "State"]
+          output_column_count = output_column.length
+          expect(knife_ec2_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
+          knife_ec2_list.run
+        end
+      end
+    end
+
+    context 'when --availability-zone is passed' do
+      before do
+        knife_ec2_list.config[:format] = 'summary'
+        allow(knife_ec2_list.ui).to receive(:warn)
+        allow(ec2_connection).to receive(:servers).and_return([])
+        allow(knife_ec2_list).to receive(:validate!)
+      end
+
+      it 'shows the availability zones in the output' do
+        knife_ec2_list.config[:az] = true
+        output_column = ["Instance ID", "Public IP", "Private IP", "Flavor", "AZ",
+            "Image", "SSH Key", "Security Groups", "IAM Profile", "State"]
+        output_column_count = output_column.length
+        expect(knife_ec2_list.ui).to receive(:list).with(output_column,:uneven_columns_across, output_column_count)
+        knife_ec2_list.run
+      end
+    end
+  end
+end

data/spec/unit/s3_source_deps_spec.rb

@@ -1,24 +1,24 @@
-require File.expand_path('../../spec_helper', __FILE__)
-
-#This spec can only be run separately from the rest due to inclusion of fog library in other specs.
-#rspec spec/unit/s3_source_deps_spec.rb
-
-describe 'Check Dependencies', :exclude => Object.constants.include?(:Fog) do
-  before(:each) do
-  end
-  it 'should not load fog by default' do
-    begin
-      Fog::Storage::AWS.new()
-    rescue Exception => e
-      expect(e).to be_a_kind_of(NameError)
-    end
-  end
-
-  it 'lazy loads fog' do
-    begin
-      Chef::Knife::S3Source.fetch('test')
-    rescue Exception => e
-      expect(e).to be_a_kind_of(ArgumentError)
-    end
-  end
-end
+require File.expand_path('../../spec_helper', __FILE__)
+
+#This spec can only be run separately from the rest due to inclusion of fog library in other specs.
+#rspec spec/unit/s3_source_deps_spec.rb
+
+describe 'Check Dependencies', :exclude => Object.constants.include?(:Fog) do
+  before(:each) do
+  end
+  it 'should not load fog by default' do
+    begin
+      Fog::Storage::AWS.new()
+    rescue Exception => e
+      expect(e).to be_a_kind_of(NameError)
+    end
+  end
+
+  it 'lazy loads fog' do
+    begin
+      Chef::Knife::S3Source.fetch('test')
+    rescue Exception => e
+      expect(e).to be_a_kind_of(ArgumentError)
+    end
+  end
+end