knife-cloud 1.2.1 → 1.2.3

data/spec/support/shared_examples_for_service.rb

@@ -1,85 +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 'chef/knife/cloud/service'
-
-shared_examples_for Chef::Knife::Cloud::Service do |instance|
-
-  describe "#connection" do
-    it "creates a connection to fog service." do
-      expect(instance).to receive(:add_api_endpoint)
-      expect(Fog::Compute).to receive(:new)
-      instance.connection
-    end
-  end
-
-  describe "#delete_server" do
-    it "deletes the server." do
-      server = double()
-      allow(instance).to receive(:puts)
-      allow(instance).to receive_message_chain(:connection, :servers, :get).and_return(server)
-      expect(server).to receive(:name).ordered
-      expect(server).to receive(:id).ordered
-      allow(instance).to receive_message_chain(:ui, :confirm)
-      expect(server).to receive(:destroy).ordered
-      instance.delete_server(:server_name)
-    end
-
-    it "throws error message when the server cannot be located." do
-      server_name = "invalid_server_name"
-      error_message = "Could not locate server '#{server_name}'."
-      allow(instance).to receive_message_chain(:connection, :servers, :get).and_return(nil)
-      allow(instance).to receive_message_chain(:ui, :error).with(error_message)
-      expect { instance.delete_server(server_name) }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ServerDeleteError)
-    end
-  end
-
-  describe "#create_server" do
-    before do
-      allow(instance).to receive(:puts)
-      allow(instance).to receive(:print)
-    end
-
-    it "creates the server." do
-      server = double()
-      allow(instance).to receive_message_chain(:connection, :servers, :create).and_return(server)
-      allow(instance).to receive_message_chain(:ui, :color)
-      expect(server).to receive(:wait_for)
-      instance.create_server({:server_create_timeout => 600})
-    end
-  end
-
-  describe "#get_server" do
-    it "return server." do
-      server = double()
-      allow(instance).to receive_message_chain(:connection, :servers, :create).and_return(server)
-      expect(instance.connection.servers).to receive(:get)
-      instance.get_server("instance_id")
-    end
-  end
-
-  describe "#server_summary" do
-    it "show server details." do
-      server = double()
-      instance.ui = double()
-      expect(instance.ui).to receive(:list)
-      expect(server).to receive(:id)
-      instance.server_summary(server, [{:label => 'Instance ID', :key => 'id'}])
-    end
-  end  
-end

data/spec/unit/bootstrap_protocol_spec.rb

@@ -1,98 +0,0 @@
-#
-# 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/chefbootstrap/bootstrap_protocol'
-require 'chef/knife/bootstrap'
-
-describe Chef::Knife::Cloud::BootstrapProtocol do
-  before do
-    @config = {:bootstrap_protocol => 'ssh'}
-    @instance = Chef::Knife::Cloud::BootstrapProtocol.new(@config)
-  end
-
-  context "BootstrapProtocol initializer" do
-    it "asks for compulsory properties while creating @instance" do
-      expect {Chef::Knife::Cloud::BootstrapProtocol.new}.to raise_error(ArgumentError)
-    end
-
-    it "creating @instance" do
-      expect {Chef::Knife::Cloud::BootstrapProtocol.new(@config)}.to_not raise_error
-      expect(Chef::Knife::Cloud::BootstrapProtocol.new(@config).class).to eq(Chef::Knife::Cloud::BootstrapProtocol)
-    end
-  end
-
-  describe "#send_bootstrap_command" do
-    it "execute with correct method calls" do
-      @instance.bootstrap = double()
-      expect(@instance).to receive(:wait_for_server_ready).ordered
-      expect(@instance).to receive(:init_bootstrap_options).ordered
-      expect(@instance.bootstrap).to receive(:run)
-      @instance.send_bootstrap_command
-    end
-  end
-
-  describe "#init_bootstrap_options" do
-    it "set correct bootstrap config" do
-      @config[:bootstrap_ip_address] = "127.0.0.1"
-      @config[:chef_node_name] = "testnode"
-      @config[:environment] = "_default"
-      @config[:first_boot_attributes] = "{\"foo\":\"bar\"}"
-      @config[:secret] = "secret"
-      @config[:secret_file] = "secret_file"
-      @config[:template_file] = "../template_file"
-      @config[:bootstrap_vault_file] = "/foo/bar/baz"
-      @config[:bootstrap_vault_json] = '{ "vault": "item1" }'
-      @config[:bootstrap_vault_item] = { 'vault' => 'item1' }
-      @config[:bootstrap_template] = "../template_file"
-      @config[:node_ssl_verify_mode] = "none"
-      @config[:node_verify_api_cert] = true
-      @config[:bootstrap_url] = "https://www.chef.io/chef/install.sh"
-      @config[:bootstrap_install_command] = "curl -l https://www.chef.io/chef/install.sh | sudo bash -s --"
-      @config[:bootstrap_wget_options] = "-e use_proxy=yes -e http://myproxy.com:8080"
-      @config[:bootstrap_curl_options] = "--proxy http://myproxy.com:8080"
-      @config[:use_sudo_password] = "true"
-      @config[:msi_url] = "https://opscode-omnibus-packages.s3.amazonaws.com/windows/2008r2/x86_64/chef-client-12.3.0-1.msi"
-      @config[:session_timeout] = "42"
-      @config[:install_as_service] = "true"
-      allow(@config).to receive(:locate_config_value).and_return({})
-      @instance.bootstrap = Chef::Knife::Bootstrap.new
-      @instance.init_bootstrap_options
-      expect(@instance.bootstrap.name_args).to eq([@config[:bootstrap_ip_address]])
-      expect(@instance.bootstrap.config[:chef_node_name]).to eq(@config[:chef_node_name])
-      expect(@instance.bootstrap.config[:environment]).to eq(@config[:environment])
-      expect(@instance.bootstrap.config[:first_boot_attributes]).to eq(@config[:first_boot_attributes])
-      expect(@instance.bootstrap.config[:secret]).to eq(@config[:secret])
-      expect(@instance.bootstrap.config[:secret_file]).to eq(@config[:secret_file])
-      expect(@instance.bootstrap.config[:template_file]).to eq(@config[:template_file])
-      expect(@instance.bootstrap.config[:bootstrap_vault_file]).to eq(@config[:bootstrap_vault_file])
-      expect(@instance.bootstrap.config[:bootstrap_vault_json]).to eq(@config[:bootstrap_vault_json])
-      expect(@instance.bootstrap.config[:bootstrap_vault_item]).to eq(@config[:bootstrap_vault_item])
-      expect(@instance.bootstrap.config[:bootstrap_template]).to eq(@config[:bootstrap_template])
-      expect(@instance.bootstrap.config[:node_ssl_verify_mode]).to eq(@config[:node_ssl_verify_mode])
-      expect(@instance.bootstrap.config[:node_verify_api_cert]).to eq(@config[:node_verify_api_cert])
-      expect(@instance.bootstrap.config[:bootstrap_url]).to eq(@config[:bootstrap_url])
-      expect(@instance.bootstrap.config[:bootstrap_install_command]).to eq(@config[:bootstrap_install_command])
-      expect(@instance.bootstrap.config[:bootstrap_wget_options]).to eq(@config[:bootstrap_wget_options])
-      expect(@instance.bootstrap.config[:bootstrap_curl_options]).to eq(@config[:bootstrap_curl_options])
-      expect(@instance.bootstrap.config[:use_sudo_password]).to eq(@config[:use_sudo_password])
-      expect(@instance.bootstrap.config[:msi_url]).to eq(@config[:msi_url])
-      expect(@instance.bootstrap.config[:install_as_service]).to eq(@config[:install_as_service])
-      expect(@instance.bootstrap.config[:session_timeout]).to eq(@config[:session_timeout])
-    end
-  end
-end

data/spec/unit/bootstrapper_spec.rb

@@ -1,171 +0,0 @@
-#
-# 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/chefbootstrap/bootstrapper'
-require 'chef/knife/bootstrap_windows_ssh'
-
-describe Chef::Knife::Cloud::Bootstrapper do
-  before(:each) do
-    @config = {:bootstrap_protocol => 'ssh'}
-    @instance = Chef::Knife::Cloud::Bootstrapper.new(@config)
-  end
-
-  context "Bootstrapper initializer" do
-    it "asks for compulsory properties while creating instance" do
-      expect {Chef::Knife::Cloud::Bootstrapper.new}.to raise_error(ArgumentError)
-    end
-
-    it "creating instance" do
-      expect {Chef::Knife::Cloud::Bootstrapper.new(@config)}.to_not raise_error
-      expect(Chef::Knife::Cloud::Bootstrapper.new(@config).class).to eq(Chef::Knife::Cloud::Bootstrapper)
-    end
-  end
-
-  describe "#bootstrap Linux machine with ssh" do
-    it "executes with correct method calls" do
-      @ssh_bootstrap_protocol = Chef::Knife::Cloud::SshBootstrapProtocol.new(@config)
-      allow(@instance).to receive(:create_bootstrap_protocol).and_return(@ssh_bootstrap_protocol)
-      @unix_distribution = Chef::Knife::Cloud::UnixDistribution.new(@config)
-      expect(@instance).to receive(:create_bootstrap_protocol).ordered
-      allow(@instance).to receive(:create_bootstrap_distribution).and_return(@unix_distribution)
-      expect(@ssh_bootstrap_protocol).to receive(:send_bootstrap_command).ordered
-      @instance.bootstrap
-    end
-  end
-
-  describe "#bootstrap Windows machine with winrm" do
-    it "executes with correct method calls" do
-      @winrm_bootstrap_protocol = Chef::Knife::Cloud::WinrmBootstrapProtocol.new(@config)
-      allow(@instance).to receive(:create_bootstrap_protocol).and_return(@winrm_bootstrap_protocol)
-      @windows_distribution = Chef::Knife::Cloud::WindowsDistribution.new(@config)
-      expect(@instance).to receive(:create_bootstrap_protocol).ordered
-      allow(@instance).to receive(:create_bootstrap_distribution).and_return(@windows_distribution)
-      expect(@winrm_bootstrap_protocol).to receive(:send_bootstrap_command).ordered
-      @instance.bootstrap
-    end
-  end
-
-  describe "#create_bootstrap_distribution" do
-      context "when image_os_type set to windows" do
-        before(:each) do
-          @config[:image_os_type] = "windows"
-        end
-
-        it "instantiates Windows Distribution class." do
-          expect(Chef::Knife::Cloud::WindowsDistribution).to receive(:new).with(@config)
-          @instance.create_bootstrap_distribution
-        end
-
-        it "doesn't instantiate Unix Distribution class." do
-          expect(Chef::Knife::Cloud::UnixDistribution).to_not receive(:new)
-          @instance.create_bootstrap_distribution
-        end
-
-      end
-
-      context "when image_os_type set to linux" do
-        before(:each) do
-          @config[:image_os_type] = "linux"
-        end
-
-        it "instantiates Unix Distribution class." do
-          expect(Chef::Knife::Cloud::UnixDistribution).to receive(:new).with(@config)
-          @instance.create_bootstrap_distribution
-        end
-
-        it "doesn't instantiate Windows Distribution class." do
-          expect(Chef::Knife::Cloud::WindowsDistribution).to_not receive(:new)
-          @instance.create_bootstrap_distribution
-        end
-      end
-
-      context "when image_os_type set to invalid" do
-        before(:each) do
-          @config[:image_os_type] = "invalid"
-        end
-
-        it "raise bootstrap error" do
-          ui = double()
-          expect(@instance).to receive(:ui).and_return(ui)
-          allow(ui).to receive(:fatal)
-          expect { @instance.create_bootstrap_distribution }.to raise_error(Chef::Knife::Cloud::CloudExceptions::BootstrapError, "Invalid bootstrap distribution. image_os_type should be either windows or linux.")
-        end
-      end      
-    end
-
-
-  describe "#create_bootstrap_protocol" do
-    context "when bootstrap_protocol set to ssh" do
-      before(:each) do
-        @config[:bootstrap_protocol] = "ssh"
-      end
-
-      it "instantiates SshBootstrapProtocol class." do
-        expect(Chef::Knife::Cloud::SshBootstrapProtocol).to receive(:new)
-        @instance.create_bootstrap_protocol
-      end
-
-      it "doesn't instantiate Windows Distribution class." do
-        expect(Chef::Knife::Cloud::WinrmBootstrapProtocol).to_not receive(:new)
-        @instance.create_bootstrap_protocol
-      end
-
-    end
-
-    context "when bootstrap_protocol set to winrm" do
-      before(:each) do
-        @config[:bootstrap_protocol] = "winrm"
-      end
-
-      it "instantiates WinrmBootstrapProtocol class." do
-        expect(Chef::Knife::Cloud::WinrmBootstrapProtocol).to receive(:new)
-        @instance.create_bootstrap_protocol
-      end
-
-      it "doesn't instantiate SshBootstrapProtocol class." do
-        expect(Chef::Knife::Cloud::SshBootstrapProtocol).to_not receive(:new)
-        @instance.create_bootstrap_protocol
-      end
-    end
-
-    context "when bootstrap_protocol set to nil." do
-      before do
-        @config[:bootstrap_protocol] = nil
-      end
-
-      it "instantiates SshBootstrapProtocol class." do
-        expect(Chef::Knife::Cloud::SshBootstrapProtocol).to receive(:new)
-        @instance.create_bootstrap_protocol
-      end
-    end
-
-    context "when bootstrap_protocol set to invalid." do
-      before do
-        @config[:bootstrap_protocol] = "invalid"
-      end
-
-      it "instantiates SshBootstrapProtocol class." do
-        ui = double()
-        expect(@instance).to receive(:ui).and_return(ui)
-        allow(ui).to receive(:fatal)
-        expect { @instance.create_bootstrap_protocol }.to raise_error(Chef::Knife::Cloud::CloudExceptions::BootstrapError, "Invalid bootstrap protocol.")
-      end
-    end    
-  end
-end

data/spec/unit/cloud_command_spec.rb

@@ -1,35 +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 File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'support/shared_examples_for_command'
-
-describe Chef::Knife::Cloud::Command do
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::Command.new
-
-  let (:instance) { Chef::Knife::Cloud::Command.new }
-
-  it "overrides execute_command" 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 execute_command in #{instance.to_s}")
-  end
-
-  it { expect {instance.run}.to raise_error(Chef::Exceptions::Override, "You must override create_service_instance in #{instance.to_s} to create cloud specific service") }
-
-end
-

data/spec/unit/command_spec.rb

@@ -1,49 +0,0 @@
-#
-# 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'
-
-describe Chef::Knife::Cloud::Command do
-  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::Command.new
-  
-  describe "validate!" do
-    before(:each) do
-      # Here following options are used as a test data.
-      Chef::Config[:knife][:cloud_provider_username] = "cloud_provider_username"
-      Chef::Config[:knife][:cloud_provider_password] = "cloud_provider_password"
-      Chef::Config[:knife][:cloud_provider_auth_url] = "cloud_provider_auth_url"
-      @instance = Chef::Knife::Cloud::Command.new
-      allow(@instance.ui).to receive(:error)
-    end
-    
-    after(:all) do
-      Chef::Config[:knife].delete(:cloud_provider_username)
-      Chef::Config[:knife].delete(:cloud_provider_password)
-      Chef::Config[:knife].delete(:cloud_provider_auth_url)
-    end
-
-    it "execute with success" do
-      expect { @instance.validate!(:cloud_provider_username, :cloud_provider_password, :cloud_provider_auth_url) }.to_not raise_error 
-    end
-
-    it "raise_error on any mandatory option is missing" do
-      # delete cloud_provide_username option.
-      Chef::Config[:knife].delete(:cloud_provider_username)
-      expect { @instance.validate!(:cloud_provider_username, :cloud_provider_password, :cloud_provider_auth_url) }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ValidationError, " You did not provide a valid 'Cloud Provider Username' value..")
-    end
-  end
-end

data/spec/unit/fog_service_spec.rb

@@ -1,163 +0,0 @@
-#
-# 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 File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
-require 'chef/knife/cloud/fog/service'
-require 'support/shared_examples_for_service'
-
-describe Chef::Knife::Cloud::FogService do
-
-  it_behaves_like Chef::Knife::Cloud::Service, Chef::Knife::Cloud::FogService.new
-
-  let (:instance) { Chef::Knife::Cloud::FogService.new({:auth_params => {:provider => 'Any Cloud Provider'}}) }
-
-  context "connection" do
-    before do
-      allow(instance).to receive(:exit)
-    end
-
-    it "creates a connection to fog service with the provided auth params." do
-      expect(instance).to receive(:add_api_endpoint)
-      expect(Fog::Compute).to receive(:new).with({:provider => 'Any Cloud Provider'})
-      instance.connection
-    end
-  end
-
-  context "network" do
-    it "creates a connection to fog network with the provided auth params." do
-      expect(Fog::Network).to receive(:new).with({:provider => 'Any Cloud Provider'})
-      instance.network
-    end
-
-    context "connection to fog" do
-      before do
-        allow(instance).to receive(:exit)
-        allow(instance).to receive(:ui).and_return(Object.new)
-        expect(instance.ui).to receive(:fatal)
-      end
-
-      it "handles Unauthorized exception." do
-        expect(Fog::Network).to receive(:new).with({:provider => 'Any Cloud Provider'}).and_raise Excon::Errors::Unauthorized.new("Unauthorized")
-        expect {instance.network}.to raise_error(Chef::Knife::Cloud::CloudExceptions::ServiceConnectionError)
-      end
-
-      it "handles SocketError or any other connection exception." do
-        socket_error = Excon::Errors::SocketError.new(Exception.new "Mock Error")
-        expect(Fog::Network).to receive(:new).with({:provider => 'Any Cloud Provider'}).and_raise socket_error
-        expect {instance.network}.to raise_error(Chef::Knife::Cloud::CloudExceptions::ServiceConnectionError)
-      end
-
-      it "handles NetworkNotFoundError exception." do
-        expect(Fog::Network).to receive(:new).with({:provider => 'Any Cloud Provider'}).and_raise Fog::Errors::NotFound.new("NotFound")
-        expect {instance.network}.to raise_error(Chef::Knife::Cloud::CloudExceptions::NetworkNotFoundError)
-      end
-    end
-  end
-
-  context "add_custom_attributes" do
-    before(:each) do
-      Chef::Config[:knife][:custom_attributes] = [{"state"=>"Inactive"}]
-      @server_def = {:name=>"vm-1", :image_ref=>"123",:flavor_ref=>"2", :key_name=>"key"}
-      instance.add_custom_attributes(@server_def)
-    end
-
-    it "adds the custom attributes provided to server_def" do
-      expect(@server_def.include?(:state)).to be true
-    end
-
-    it "sets the provided attributes with supplied values" do
-      expect(@server_def[:state] == "Inactive").to be true
-    end
-  end
-
-  ["servers", "images", "networks"].each do |resource_type|
-    resource =  case resource_type
-                when "networks"
-                  :network
-                else
-                  :connection
-                end
-    context "list #{resource_type}" do
-
-      it "lists #{resource_type} of the current cloud service provider account." do
-        allow(instance).to receive_message_chain(resource.to_sym, "#{resource_type}".to_sym, :all)
-        instance.method("list_#{resource_type}").call
-      end
-
-      it "handles Excon::Errors::BadRequest exception." do
-        allow(instance).to receive(:ui).and_return(Object.new)
-        allow(instance.ui).to receive(:fatal)
-        allow(instance).to receive_message_chain(resource.to_sym, "#{resource_type}".to_sym, :all).and_raise Excon::Errors::BadRequest.new("Invalid Resource")
-        expect {instance.method("list_#{resource_type}").call}.to raise_error(Chef::Knife::Cloud::CloudExceptions::CloudAPIException)
-      end
-    end
-  end
-
-  context "#delete_server" do
-    before(:each) do
-      @server = TestResource.new({:id => "test-server1"})
-      @server.define_singleton_method(:destroy){}
-    end
-
-    it "delete instance successfully" do
-      server_name = "test-server1"
-      instance.ui = double
-      expect(instance).to receive(:get_server).and_return(@server)
-      expect(instance).to receive(:get_server_name).and_return(server_name)
-      expect(instance).to receive(:msg_pair).with("Instance Name", server_name)
-      expect(instance).to receive(:msg_pair).with("Instance ID", @server.id)
-      expect(instance.ui).to receive(:confirm)
-      expect(@server).to receive(:destroy)
-      instance.delete_server(server_name)
-    end
-
-    it "raise_error on non existence server delete " do
-      server_name = "test-server1"
-      instance.ui = double
-      error_message = "Could not locate server '#{server_name}'."
-      expect(instance).to receive(:get_server).and_return(nil)
-      expect(instance.ui).to receive(:error).with(error_message)
-      expect { instance.delete_server(server_name) }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ServerDeleteError, error_message)
-    end
-  end
-
-  context '#release_address' do
-    before(:each) do
-      allow(instance).to receive(:add_api_endpoint)
-      allow(Fog::Compute).to receive(:new).with({:provider => 'Any Cloud Provider'})
-    end
-
-    it 'releases address successfully' do
-      address_id = 'test-addres-id'
-      @address = TestResource.new('body' => { 'floating_ip' =>
-                                            { 'instance_id' => nil,
-                                              'ip' => '127.0.0.1',
-                                              'fixed_ip' => nil,
-                                              'id' => 'test-addres-id',
-                                              'pool' => 'public-110'
-                                            }
-                                          })
-      instance.ui = double
-      expect(instance).to receive(:get_address).and_return(@address)
-      expect(instance).to receive(:msg_pair).with('IP address', '127.0.0.1')
-      expect(instance.ui).to receive(:confirm)
-      allow(instance.connection).to receive(:release_address)
-      instance.release_address(address_id)
-    end
-  end
-end