knife-cloud 1.2.1 → 1.2.3

data/spec/unit/list_resource_command_spec.rb

@@ -1,140 +0,0 @@
-#
-# Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
-# Author:: Prabhu Das (<prabhu.das@clogeny.com>)
-# Author:: Siddheshwar More (<siddheshwar.more@clogeny.com>)
-# Copyright:: Copyright (c) 2013-2014 Chef Software, Inc.
-# 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 'spec_helper'
-require 'chef/knife/cloud/list_resource_command'
-require 'support/shared_examples_for_command'
-require 'excon/errors'
-
-describe Chef::Knife::Cloud::ResourceListCommand do
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::ResourceListCommand.new
-
-  let (:instance) {Chef::Knife::Cloud::ResourceListCommand.new}
-  let (:resources) {[ TestResource.new({:id => "resource-1", :os => "ubuntu"}),
-                   TestResource.new({:id => "resource-2", :os => "windows"})]}
-
-  context "Basic tests:" do
-    it "raises exception to override #query_resource method" do
-      allow(instance).to receive(:create_service_instance).and_return(Chef::Knife::Cloud::Service.new)
-      expect {instance.run}.to raise_error(Chef::Exceptions::Override, "You must override query_resource in #{instance.to_s} to return resources.")
-    end
-
-    it "responds to #list method" do
-      allow(instance).to receive(:query_resource)
-      expect(instance).to respond_to(:list)
-    end
-
-    context "responds to #list method" do
-      let(:test_resource) { "test" }
-      before(:each) do
-        expect(instance.ui).to receive(:fatal)
-        instance.config[:format] = "summary"
-      end
-
-      it "handle generic exception" do
-        allow(test_resource).to receive(:sort_by).and_raise StandardError
-        expect {instance.list(test_resource)}.to raise_error(StandardError)
-      end
-
-      it "handle Excon::Errors::BadRequest exception." do
-        allow(test_resource).to receive(:sort_by).and_raise Excon::Errors::BadRequest.new("excon error message")
-        expect {instance.list(test_resource)}.to raise_error(Excon::Errors::BadRequest)
-      end
-    end
-  end
-
-  context "Without columns_with_info parameter in #list:" do
-    before do
-      allow(instance).to receive(:query_resource).and_return(resources)
-      allow(instance).to receive(:create_service_instance).and_return(Chef::Knife::Cloud::Service.new)
-      allow(instance).to receive(:puts)
-      instance.config[:format] = "summary"
-    end
-
-    it "lists resources in json format when columns_with_info parameter is empty" do
-      expect(instance).to receive(:puts).with(resources[0].to_json)
-      expect(instance).to receive(:puts).with(resources[1].to_json)
-      expect(instance).to receive(:puts).with("\n").twice
-      instance.run
-    end
-  end
-
-  context "With columns_with_info parameter in #list:" do
-    context "#value_callback not specified in columns_with_info" do
-      before do
-        class Derived < Chef::Knife::Cloud::ResourceListCommand
-          attr_accessor :resource_filters
-          def before_exec_command
-            @columns_with_info = [ { :key => 'id', :label => 'Instance ID' },
-                                 { :key => 'os', :label => 'Operating system' } ]
-          end
-        end
-
-        @derived_instance = Derived.new
-        allow(@derived_instance).to receive(:query_resource).and_return(resources)
-        allow(@derived_instance).to receive(:puts)
-        allow(@derived_instance).to receive(:create_service_instance).and_return(Chef::Knife::Cloud::Service.new)
-        @derived_instance.config[:format] = "summary"
-      end
-
-      it "lists all resources" do
-        expect(@derived_instance.ui).to receive(:list).with(["Instance ID", "Operating system", "resource-1", "ubuntu", "resource-2", "windows"], :uneven_columns_across, 2)
-        @derived_instance.run
-      end
-
-      it "excludes resource when filter is specified" do
-        @derived_instance.resource_filters = [{:attribute => 'id', :regex => /^resource-1$/}]
-        expect(@derived_instance.ui).to receive(:list).with(["Instance ID", "Operating system", "resource-2", "windows"], :uneven_columns_across, 2)
-        @derived_instance.run
-      end
-
-      it "lists all resources when disable filter" do
-        @derived_instance.config[:disable_filter] = true
-        @derived_instance.resource_filters = [{:attribute => 'id', :regex => /^resource-1$/}]
-        expect(@derived_instance.ui).to receive(:list).with(["Instance ID", "Operating system", "resource-1", "ubuntu", "resource-2", "windows"], :uneven_columns_across, 2)
-        @derived_instance.run
-      end
-    end
-    context "#value_callback specified in columns_with_info" do
-      before do
-        class Derived < Chef::Knife::Cloud::ResourceListCommand
-          attr_accessor :resource_filters
-          def before_exec_command
-            @columns_with_info = [ { :key => 'id', :label => 'Instance ID' },
-                               { :key => 'os', :label => 'Operating system', :value_callback => method(:format_os) } ]
-          end
-          def format_os(os)
-            (os == 'ubuntu') ? "ubuntu - operating system with Linux kernel" : os
-          end
-        end
-
-        @derived_instance = Derived.new
-        allow(@derived_instance).to receive(:query_resource).and_return(resources)
-        allow(@derived_instance).to receive(:puts)
-        allow(@derived_instance).to receive(:create_service_instance).and_return(Chef::Knife::Cloud::Service.new)
-        @derived_instance.config[:format] = "summary"
-      end
-
-      it "lists formatted list of resources" do
-        expect(@derived_instance.ui).to receive(:list).with(["Instance ID", "Operating system", "resource-1", "ubuntu - operating system with Linux kernel", "resource-2", "windows"], :uneven_columns_across, 2)
-        @derived_instance.run
-      end
-    end
-  end
-end

data/spec/unit/server_create_command_spec.rb

@@ -1,198 +0,0 @@
-#
-# Author:: Mukta Aphale (<mukta.aphale@clogeny.com>)
-# Author:: Siddheshwar More (<siddheshwar.more@clogeny.com>)
-# Copyright:: Copyright (c) 2013-2014 Chef Software, Inc.
-# 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 'support/shared_examples_for_command'
-require 'support/shared_examples_for_servercreatecommand'
-require 'net/ssh'
-require 'chef/knife/cloud/server/create_options'
-
-describe Chef::Knife::Cloud::ServerCreateCommand do
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::ServerCreateCommand.new
-  it_behaves_like Chef::Knife::Cloud::ServerCreateCommand, Chef::Knife::Cloud::ServerCreateCommand.new
-
-  describe "#validate_params!" do
-    before(:each) do
-      @instance = Chef::Knife::Cloud::ServerCreateCommand.new
-      allow(@instance.ui).to receive(:error)
-      Chef::Config[:knife][:bootstrap_protocol] = "ssh"
-      Chef::Config[:knife][:identity_file] = "identity_file"
-      Chef::Config[:knife][:ssh_password] = "ssh_password"
-      Chef::Config[:knife][:chef_node_name] = "chef_node_name"
-      Chef::Config[:knife][:winrm_password] = "winrm_password"
-    end
-    after(:all) do
-      Chef::Config[:knife].delete(:bootstrap_protocol)
-      Chef::Config[:knife].delete(:identity_file)
-      Chef::Config[:knife].delete(:chef_node_name)
-      Chef::Config[:knife].delete(:ssh_password)
-      Chef::Config[:knife].delete(:winrm_password)
-    end
-
-    it "run sucessfully on all params exist" do
-      expect { @instance.validate_params! }.to_not raise_error
-      expect(@instance.config[:chef_node_name]).to eq(Chef::Config[:knife][:chef_node_name])
-    end
-
-    context "when bootstrap_protocol ssh" do
-      it "raise error on ssh_password and identity_file are missing" do
-        Chef::Config[:knife].delete(:identity_file)
-        Chef::Config[:knife].delete(:ssh_password)
-        expect { @instance.validate_params! }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ValidationError, " You must provide either Identity file or SSH Password..")
-      end
-    end
-
-    context "when bootstrap_protocol winrm" do
-      it "raise error on winrm_password is missing" do
-        Chef::Config[:knife][:bootstrap_protocol] = "winrm"
-        Chef::Config[:knife].delete(:winrm_password)
-        expect { @instance.validate_params! }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ValidationError, " You must provide Winrm Password..")
-      end
-    end
-  end
-
-  describe "#after_exec_command" do
-    it "calls bootstrap" do
-      instance = Chef::Knife::Cloud::ServerCreateCommand.new
-      expect(instance).to receive(:bootstrap)
-      instance.after_exec_command
-    end
-
-    it "delete server on bootstrap failure" do
-      instance = Chef::Knife::Cloud::ServerCreateCommand.new
-      instance.service = Chef::Knife::Cloud::Service.new
-      allow(instance).to receive(:raise)
-      allow(instance.ui).to receive(:fatal)
-      instance.config[:delete_server_on_failure] = true
-      allow(instance).to receive(:bootstrap).and_raise(Chef::Knife::Cloud::CloudExceptions::BootstrapError)
-      expect(instance.service).to receive(:delete_server_dependencies)
-      expect(instance.service).to receive(:delete_server_on_failure)
-      instance.after_exec_command
-    end
-
-    # Currently the RangeError is occured when image_os_type is set to linux and bootstrap-protocol is set to ssh before windows server bootstrap.
-    it "raise error message when bootstrap fails due to image_os_type not exist" do
-      instance = Chef::Knife::Cloud::ServerCreateCommand.new
-      instance.service = Chef::Knife::Cloud::Service.new
-      allow(instance.ui).to receive(:fatal)
-      instance.config[:delete_server_on_failure] = true
-      allow(instance).to receive(:bootstrap).and_raise(RangeError)
-      expect(instance.service).to receive(:delete_server_dependencies)
-      expect(instance.service).to receive(:delete_server_on_failure)
-      expect { instance.after_exec_command }.to raise_error(RangeError, "Check if --bootstrap-protocol and --image-os-type is correct. RangeError")
-    end
-  end
-
-  describe "#set_default_config" do
-    it "set valid image os type" do
-      instance = Chef::Knife::Cloud::ServerCreateCommand.new
-      instance.config[:bootstrap_protocol] = 'winrm'
-      instance.set_default_config
-      expect(instance.config[:image_os_type]).to eq('windows')
-    end
-  end
-
-  class ServerCreate < Chef::Knife::Cloud::ServerCreateCommand
-    include Chef::Knife::Cloud::ServerCreateOptions
-  end
-
-  describe "#bootstrap options" do
-
-    it "set chef config knife options" do
-      instance = ServerCreate.new
-      bootstrap_url = "bootstrap_url"
-      bootstrap_install_command = "bootstrap_install_command"
-      bootstrap_wget_options = "bootstrap_wget_options"
-      bootstrap_curl_options = "bootstrap_curl_options"
-      bootstrap_no_proxy = "bootstrap_no_proxy"
-
-      instance.options[:bootstrap_url][:proc].call bootstrap_url
-      expect(Chef::Config[:knife][:bootstrap_url]).to eq(bootstrap_url)
-
-      instance.options[:bootstrap_install_command][:proc].call bootstrap_install_command
-      expect(Chef::Config[:knife][:bootstrap_install_command]).to eq(bootstrap_install_command)
-
-      instance.options[:bootstrap_wget_options][:proc].call bootstrap_wget_options
-      expect(Chef::Config[:knife][:bootstrap_wget_options]).to eq(bootstrap_wget_options)
-
-      instance.options[:bootstrap_curl_options][:proc].call bootstrap_curl_options
-      expect(Chef::Config[:knife][:bootstrap_curl_options]).to eq(bootstrap_curl_options)
-
-      instance.options[:bootstrap_no_proxy][:proc].call bootstrap_no_proxy
-      expect(Chef::Config[:knife][:bootstrap_no_proxy]).to eq(bootstrap_no_proxy)      
-
-      expect(instance.options[:auth_timeout][:default]).to eq(25)
-    end
-  end
-
-  describe "#before_bootstrap" do
-
-    before(:all) { @instance = ServerCreate.new }
-
-    context "bootstrap_protocol shh" do
-      before {@instance.config[:bootstrap_protocol] = "ssh"}
-      
-      it "set ssh_user value by using -x option for ssh bootstrap protocol or linux image" do
-        # Currently -x option set config[:winrm_user]
-        # default value of config[:ssh_user] is root
-        @instance.config[:winrm_user] = "ubuntu"
-        @instance.config[:ssh_user] = "root"
-
-        @instance.before_bootstrap
-        expect(@instance.config[:ssh_user]).to eq("ubuntu")
-      end
-
-      it "set ssh_password value by using -P option for ssh bootstrap protocol or linux image" do
-        # Currently -P option set config[:winrm_password]
-        # default value of config[:ssh_password] is nil
-        @instance.config[:winrm_password] = "winrm_password"
-        @instance.config[:ssh_password] = nil
-
-        @instance.before_bootstrap
-        expect(@instance.config[:ssh_password]).to eq("winrm_password")
-      end
-
-      it "set ssh_port value by using -p option for ssh bootstrap protocol or linux image" do
-        # Currently -p option set config[:winrm_port]
-        # default value of config[:ssh_port] is 22
-        @instance.config[:winrm_port] = "1234"
-        @instance.config[:ssh_port] =  "22"
-
-        @instance.before_bootstrap
-        expect(@instance.config[:ssh_port]).to eq("1234")
-      end
-
-      it "set identity_file value by using -i option for ssh bootstrap protocol or linux image" do
-        # Currently -i option set config[:kerberos_keytab_file]
-        # default value of config[:identity_file] is nil
-        @instance.config[:kerberos_keytab_file] = "kerberos_keytab_file"
-        @instance.config[:identity_file] = nil
-
-        @instance.before_bootstrap
-        expect(@instance.config[:identity_file]).to eq("kerberos_keytab_file")
-      end
-    end
-
-    context "bootstrap_protocol winrm" do
-      it "skip ssh_override_winrm" do
-        @instance.config[:bootstrap_protocol] = "winrm"
-        expect(@instance).to_not receive(:ssh_override_winrm)
-        @instance.before_bootstrap
-      end
-    end
-  end
-end

data/spec/unit/server_delete_command_spec.rb

@@ -1,25 +0,0 @@
-#
-# Author:: Kaustubh Deorukhkar (<kaustubh@clogeny.com>)
-# Copyright:: Copyright (c) 2013 Chef Software, Inc.
-# 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 'spec_helper'
-require 'support/shared_examples_for_command'
-require 'support/shared_examples_for_serverdeletecommand'
-
-describe Chef::Knife::Cloud::ServerDeleteCommand do
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::ServerDeleteCommand.new
-  it_behaves_like Chef::Knife::Cloud::ServerDeleteCommand, Chef::Knife::Cloud::ServerDeleteCommand.new
-end

data/spec/unit/server_list_command_spec.rb

@@ -1,119 +0,0 @@
-#
-# Author:: Siddheshwar More (<siddheshwar.more@clogeny.com>)
-# Author:: Prabhu Das (<prabhu.das@clogeny.com>)
-# Copyright:: Copyright (c) 2013-2014 Chef Software, Inc.
-# 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 'spec_helper'
-require 'support/shared_examples_for_command'
-require 'chef/knife/cloud/server/list_command'
-require 'chef/node'
-
-describe Chef::Knife::Cloud::ServerListCommand do
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::ServerListCommand.new
-
-  describe "#before_exec_command" do
-    it "set chef data columns info on chef data options" do
-      instance = Chef::Knife::Cloud::ServerListCommand.new
-      instance.config[:chef_data] = true
-      expect(Chef::Node).to receive(:list).with(true)
-      expect(instance.before_exec_command).to include({:label => "Chef Node Name", :key => "name"})
-    end
-
-    it "set chef data columns info on chef-data and chef-node-attribute options" do
-      chef_node_attribute = "platform_family"
-      instance = Chef::Knife::Cloud::ServerListCommand.new
-      instance.config[:chef_data] = true
-      instance.config[:chef_node_attribute] = chef_node_attribute
-      expect(Chef::Node).to receive(:list).with(true)
-      expect(instance.before_exec_command).to include({:label => chef_node_attribute, :key => chef_node_attribute})
-    end
-
-    it "not set chef data columns info if chef-data option is not set" do
-      instance = Chef::Knife::Cloud::ServerListCommand.new
-      expect(Chef::Node).to_not receive(:list).with(true)
-      expect(instance.before_exec_command).to be(nil)
-    end
-
-    it "not set chef data columns info on chef-node-attribute option set but chef-data option is not set" do
-      instance = Chef::Knife::Cloud::ServerListCommand.new
-      instance.config[:chef_node_attribute] = "platform_family"
-      expect(Chef::Node).to_not receive(:list).with(true)
-      expect(instance.before_exec_command).to be(nil)
-    end
-  end
-
-  describe "#get_resource_col_val" do
-    let (:resources) {[ TestResource.new({:id => "server-1", :name => "server-1", :os => "ubuntu"})]}
-    before do
-      class DerivedServerList < Chef::Knife::Cloud::ServerListCommand
-        attr_accessor :node
-        def before_exec_command
-          @columns_with_info = [ { :key => 'id', :label => 'Instance ID' }, {:label => 'Environment', :key => 'chef_environment'}, {:label => 'platform_family', :key => 'platform_family'} ]
-          @chef_data_col_info = [ {:label => 'Environment', :key => 'chef_environment'}, {:label => 'platform_family', :key => 'platform_family'} ]
-          @node = TestResource.new({:id => "server-1", :name => "server-1",
-          :chef_environment => "_default", :platform_family => "debian"})
-          @node.define_singleton_method(:attribute?) do |attribute|
-          end
-          @node_list = {"server-1" => @node}
-        end
-      end
-      @derived_instance = DerivedServerList.new
-      @derived_instance.config[:chef_data] = true
-      @derived_instance.config[:chef_node_attribute] = "platform_family"
-      @derived_instance.before_exec_command
-      @derived_instance.service = double Chef::Knife::Cloud::Service.new
-      allow(@derived_instance.service).to receive(:get_server_name).with(resources.first).and_return("server-1")
-    end
-
-    it "return columns_with_info values" do
-      expect(@derived_instance.node).to receive(:attribute?).with("platform_family").and_return(true)
-      expect(@derived_instance.get_resource_col_val(resources.first)).to eq(["server-1", "_default", "debian"])
-    end
-
-    it "raise error on invalide chef_node_attribute" do
-      allow(@derived_instance.ui).to receive(:error)
-      expect(@derived_instance.node).to receive(:attribute?).with("platform_family").and_return(false)
-      expect { @derived_instance.get_resource_col_val(resources.first) }.to raise_error(Chef::Knife::Cloud::CloudExceptions::CloudAPIException, "The Node does not have a platform_family attribute.")
-    end    
-  end
-
-  describe "#format_server_state" do
-    before(:each) do
-      @instance = Chef::Knife::Cloud::ServerListCommand.new 
-    end
-
-    %w{ shutting-down terminated stopping stopped error shutoff }.each do |state|
-      it "set state color red on server state is in #{state}" do
-        expect(@instance.ui).to receive(:color).with(state, :red)
-        @instance.format_server_state(state)
-      end
-    end
-
-    %w{ pending build paused suspended hard_reboot }.each do |state|
-      it "set state color yellow on server state is in #{state}" do
-        expect(@instance.ui).to receive(:color).with(state, :yellow)
-        @instance.format_server_state(state)
-      end
-    end
-
-    %w{ running }.each do |state|
-      it "set state color green on server state is #{state}" do
-        expect(@instance.ui).to receive(:color).with(state, :green)
-        @instance.format_server_state(state)
-      end
-    end
-  end
-end