knife-openstack 0.10.0 → 1.0.0.rc1

data/spec/spec_helper.rb

@@ -1,4 +1,130 @@
+# 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.
+
+# Author:: Siddheshwar More (<siddheshwar.more@clogeny.com>)
+
+
 $:.unshift File.expand_path('../../lib', __FILE__)
 require 'chef/knife/bootstrap'
+require 'chef/knife/openstack_helpers'
+require 'fog'
 require 'chef/knife/winrm_base'
+require 'chef/knife/bootstrap_windows_winrm'
 require 'chef/knife/openstack_server_create'
+require 'chef/knife/openstack_server_delete'
+require 'chef/knife/bootstrap_windows_ssh'
+require "securerandom"
+require 'knife-openstack/version'
+require 'test/knife-utils/test_bed'
+require 'resource_spec_helper'
+require 'server_command_common_spec_helper'
+require 'tempfile'
+
+def find_instance_id(instance_name, file)
+  file.lines.each do |line|
+    if line.include?("#{instance_name}")
+      return "#{line}".split(" ")[2].strip
+    end
+  end
+end
+
+def is_config_present
+  if ! ENV['RUN_INTEGRATION_TESTS']
+    puts("\nPlease set RUN_INTEGRATION_TESTS environment variable to run integration tests")
+    return false
+  end
+
+  unset_env_var = []
+  unset_config_options = []
+  is_config = true
+  config_file_exist = File.exist?(File.expand_path("../integration/config/environment.yml", __FILE__))
+  openstack_config = YAML.load(File.read(File.expand_path("../integration/config/environment.yml", __FILE__))) if config_file_exist
+  %w(OPENSTACK_USERNAME OPENSTACK_PASSWORD OPENSTACK_AUTH_URL OPENSTACK_TENANT).each do |os_env_var|
+      if ENV[os_env_var].nil?
+        unset_env_var <<  os_env_var
+        is_config = false
+      end
+    end
+
+  err_msg = "\nPlease set #{unset_env_var.join(', ')} environment"
+  err_msg = err_msg + ( unset_env_var.length > 1 ? " variables " : " variable " ) + "for integration tests."
+  puts err_msg unless unset_env_var.empty?
+  
+  %w(OS_SSH_USER OPENSTACK_PRI_KEY OPENSTACK_KEY_PAIR OS_WINDOWS_SSH_USER OS_WINDOWS_SSH_PASSWORD OS_WINRM_USER OS_WINRM_PASSWORD OS_LINUX_IMAGE OS_LINUX_FLAVOR OS_INVALID_FLAVOR OS_INVALID_FLOATING_IP OS_WINDOWS_FLAVOR OS_WINDOWS_IMAGE OS_WINDOWS_SSH_IMAGE OS_NETWORK_IDS OS_AVAILABILITY_ZONE).each do |os_config_opt|
+    option_value = ENV[os_config_opt] || (openstack_config[os_config_opt] if openstack_config)
+    if option_value.nil?
+      unset_config_options << os_config_opt
+      is_config = false
+    end
+  end
+
+  config_err_msg = "\nPlease set #{unset_config_options.join(', ')} config"
+  config_err_msg = config_err_msg + ( unset_config_options.length > 1 ? " options in ../spec/integration/config/environment.yml or as environment variables" : " option in ../spec/integration/config/environment.yml or as environment variable" ) + " for integration tests."
+  puts config_err_msg unless unset_config_options.empty?
+  
+  is_config
+end
+
+def get_gem_file_name
+  "knife-openstack-" + Knife::OpenStack::VERSION + ".gem"
+end
+
+def delete_instance_cmd(stdout)
+  "knife openstack server delete " + find_instance_id("Instance ID", stdout) +
+  append_openstack_creds(is_list_cmd = true) + " --yes"
+end
+
+def create_node_name(name)
+  @name_node  = (name == "linux") ? "os-integration-test-linux-#{SecureRandom.hex(4)}" :  "os-integration-test-win-#{SecureRandom.hex(4)}"
+end
+
+
+def init_openstack_test
+  init_test
+
+  begin
+    data_to_write = File.read(File.expand_path("../integration/config/incorrect_openstack.pem", __FILE__))
+    File.open("#{temp_dir}/incorrect_openstack.pem", 'w') {|f| f.write(data_to_write)}
+  rescue
+    puts "Error while creating file - incorrect_openstack.pem"
+  end
+
+  config_file_exist = File.exist?(File.expand_path("../integration/config/environment.yml", __FILE__))
+  openstack_config = YAML.load(File.read(File.expand_path("../integration/config/environment.yml", __FILE__))) if config_file_exist
+
+  %w(OS_SSH_USER OPENSTACK_KEY_PAIR OPENSTACK_PRI_KEY OS_WINDOWS_SSH_USER OS_WINDOWS_SSH_PASSWORD OS_WINRM_USER OS_WINRM_PASSWORD OS_LINUX_IMAGE OS_LINUX_FLAVOR OS_INVALID_FLAVOR OS_INVALID_FLOATING_IP OS_WINDOWS_FLAVOR OS_WINDOWS_IMAGE OS_WINDOWS_SSH_IMAGE OS_NETWORK_IDS OS_AVAILABILITY_ZONE).each do |os_config_opt|
+    instance_variable_set("@#{os_config_opt.downcase}", (openstack_config[os_config_opt] if openstack_config) || ENV[os_config_opt])
+  end
+  begin
+    key_file_path = @openstack_pri_key
+    key_file_exist = File.exist?(File.expand_path(key_file_path, __FILE__))
+    data_to_write = File.read(File.expand_path(key_file_path, __FILE__)) if key_file_exist
+    File.open("#{temp_dir}/openstack.pem", 'w') {|f| f.write(data_to_write)}
+  rescue
+    puts "Error while creating file - openstack.pem"
+  end
+end
+
+def create_sh_user_data_file
+  file = Tempfile.new(['test_user_data', '.sh'])
+  file.write("echo 'sample user data file created' >> #{Dir.tmpdir}/testuserdata.txt")
+  file.rewind
+  file
+end
+
+def delete_sh_user_data_file(file)
+  file.close
+  file.unlink
+end

data/spec/unit/openstack_flavor_list_spec.rb

@@ -0,0 +1,30 @@
+#
+# Author:: Mukta Aphale (<mukta.aphale@clogeny.com>)
+# Author:: Siddheshwar More (<siddheshwar.more@clogeny.com>)
+# Author:: Ameya Varade (<ameya.varade@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/openstack_flavor_list'
+require 'chef/knife/cloud/openstack_service'
+require 'support/shared_examples_for_command'
+require 'unit/validate_spec'
+
+describe Chef::Knife::Cloud::OpenstackFlavorList do
+  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::OpenstackFlavorList.new
+
+  include_context "#validate!", Chef::Knife::Cloud::OpenstackFlavorList.new
+end

data/spec/unit/openstack_group_list_spec.rb

@@ -0,0 +1,43 @@
+#
+# Author:: Mukta Aphale (<mukta.aphale@clogeny.com>)
+# Author:: Siddheshwar More (<siddheshwar.more@clogeny.com>)
+# Author:: Ameya Varade (<ameya.varade@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/openstack_group_list'
+require 'chef/knife/cloud/openstack_service'
+require 'support/shared_examples_for_command'
+require 'unit/validate_spec'
+
+describe Chef::Knife::Cloud::OpenstackGroupList do
+  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::OpenstackGroupList.new
+
+  include_context "#validate!", Chef::Knife::Cloud::OpenstackGroupList.new
+
+  let (:instance) {Chef::Knife::Cloud::OpenstackGroupList.new}
+
+  context "#list" do
+    before(:each) do
+      @security_groups = [TestResource.new({ "name" => "Unrestricted","description" => "testdescription", "security_group_rules" => [TestResource.new({"from_port"=>636, "group"=>{}, "ip_protocol"=>"tcp", "to_port"=>636, "parent_group_id"=>14, "ip_range"=>{"cidr"=>"0.0.0.0/0"}, "id"=>183})]})]
+    end
+
+    it "returns group list" do
+      expect(instance.ui).to receive(:list).with(["Name", "Protocol", "From", "To", "CIDR", "Description", "Unrestricted", "tcp", "636", "636", "0.0.0.0/0", "testdescription"],:uneven_columns_across, 6)
+      instance.list(@security_groups)
+    end
+  end
+end

data/spec/unit/openstack_image_list_spec.rb

@@ -0,0 +1,32 @@
+#
+# Author:: Mukta Aphale (<mukta.aphale@clogeny.com>)
+# Author:: Siddheshwar More (<siddheshwar.more@clogeny.com>)
+# Author:: Ameya Varade (<ameya.varade@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/openstack_image_list'
+require 'chef/knife/cloud/openstack_service'
+require 'support/shared_examples_for_command'
+require 'unit/validate_spec'
+
+describe Chef::Knife::Cloud::OpenstackImageList do
+  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::OpenstackImageList.new
+
+  let (:instance) {Chef::Knife::Cloud::OpenstackImageList.new}
+
+  include_context "#validate!", Chef::Knife::Cloud::OpenstackImageList.new
+end

data/spec/unit/openstack_network_list_spec.rb

@@ -0,0 +1,39 @@
+#
+# Author:: Prabhu Das (<prabhu.das@clogeny.com>)
+# Author:: Ameya Varade (<ameya.varade@clogeny.com>)
+# Copyright:: Copyright (c) 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/openstack_network_list'
+require 'chef/knife/cloud/openstack_service'
+require 'support/shared_examples_for_command'
+require 'unit/validate_spec'
+
+describe Chef::Knife::Cloud::OpenstackNetworkList do
+  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::OpenstackNetworkList.new
+
+  let (:instance) {Chef::Knife::Cloud::OpenstackNetworkList.new}
+
+  include_context "#validate!", Chef::Knife::Cloud::OpenstackNetworkList.new
+
+  context "query_resource" do
+    it "returns the networks using the fog service." do
+      instance.service = double
+      expect(instance.service).to receive(:list_networks)
+      instance.query_resource
+    end
+  end
+end

data/spec/unit/openstack_server_create_spec.rb

@@ -1,257 +1,419 @@
 #
+# Author:: Prabhu Das (<prabhu.das@clogeny.com>)
 # Author:: Mukta Aphale (<mukta.aphale@clogeny.com>)
+# Author:: Siddheshwar More (<siddheshwar.more@clogeny.com>)
+# Author:: Ameya Varade (<ameya.varade@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('../../spec_helper', __FILE__)
-require 'fog'
-require 'chef/knife/bootstrap'
-require 'chef/knife/bootstrap_windows_winrm'
-
-describe Chef::Knife::OpenstackServerCreate do
-  before do
-
-    @openstack_connection = double(Fog::Compute::OpenStack)
-    @openstack_connection.stub_chain(:flavors, :find).and_return double('flavor', {:id => 'flavor_id'})
-    @openstack_connection.stub_chain(:images, :find).and_return double('image', {:id => 'image_id'})
-    @openstack_connection.stub_chain(:addresses).and_return [double('addresses', {
-          :instance_id => nil,
-          :ip => '111.111.111.111',
-          :fixed_ip => true
-        })]
-
-    @knife_openstack_create = Chef::Knife::OpenstackServerCreate.new
-    @knife_openstack_create.initial_sleep_delay = 0
-    @knife_openstack_create.stub(:tcp_test_ssh).and_return(true)
-    @knife_openstack_create.stub(:tcp_test_winrm).and_return(true)
-
-    {
-      :image => 'image',
-      :openstack_username => 'openstack_username',
-      :openstack_password => 'openstack_password',
-      :openstack_auth_url => 'openstack_auth_url',
-      :server_create_timeout => 1000
-    }.each do |key, value|
-      Chef::Config[:knife][key] = value
-    end
-
-    @knife_openstack_create.stub(:msg_pair)
-    @knife_openstack_create.stub(:puts)
-    @knife_openstack_create.stub(:print)
-
-    @openstack_servers = double()
-    @new_openstack_server = double()
-
-    @openstack_server_attribs = { :name => 'Mock Server',
-      :id => 'id-123456',
-      :key_name => 'key_name',
-      :flavor => 'flavor_id',
-      :image => 'image_id',
-      :availability_zone => 'zone1',
-      :addresses => {
-        'foo' => [{'addr' => '34.56.78.90'}],
-        'public' => [{'addr' => '75.101.253.10'}],
-        'private' => [{'addr' => '10.251.75.20'}]
-      },
-      :password => 'password'
-    }
-
-    @openstack_server_attribs.each_pair do |attrib, value|
-      @new_openstack_server.stub(attrib).and_return(value)
-    end
-  end
+require 'chef/knife/openstack_server_create'
+require 'support/shared_examples_for_servercreatecommand'
+require 'support/shared_examples_for_command'
 
-  describe "options" do
-    before do
-      @options = @knife_openstack_create.options
-    end
+describe Chef::Knife::Cloud::OpenstackServerCreate do
+  create_instance = Chef::Knife::Cloud::OpenstackServerCreate.new
+  create_instance.define_singleton_method(:post_connection_validations){}
 
-    it "ensures default options" do
-      @options[:bootstrap_protocol][:default].should == nil
-      @options[:distro][:default].should == 'chef-full'
-      @options[:availability_zone][:default].should == nil
-      @options[:metadata][:default].should == nil
-      @options[:floating_ip][:default].should == '-1'
-      @options[:host_key_verify][:default].should == true
-      @options[:private_network][:default].should == false
-      @options[:network][:default].should == true
-      @options[:bootstrap_network][:default].should == 'public'
-      @options[:run_list][:default].should == []
-      @options[:security_groups][:default].should == ['default']
-      @options[:server_create_timeout][:default].should == 600
-      @options[:ssh_port][:default].should == '22'
-      @options[:ssh_user][:default].should == 'root'
-      @options[:first_boot_attributes][:default].should == {}
-    end
+  it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::OpenstackServerCreate.new
+  it_behaves_like Chef::Knife::Cloud::ServerCreateCommand, create_instance
 
-    it "doesn't set an OpenStack endpoint type by default" do
-        Chef::Config[:knife][:openstack_endpoint_type].should == nil
+  describe "#create_service_instance" do
+    before(:each) do
+      @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
     end
 
-    it "user_data should be empty" do
-        Chef::Config[:knife][:user_data].should == nil
+    it "return OpenstackService instance" do
+      expect(@instance.create_service_instance).to be_an_instance_of(Chef::Knife::Cloud::OpenstackService)
     end
+
+    it "has custom_arguments as its option" do
+      expect(@instance.options.include? :custom_attributes).to be true
+     end
   end
 
-  describe "run" do
-    before do
-      @openstack_servers.should_receive(:create).and_return(@new_openstack_server)
-      @openstack_connection.should_receive(:servers).and_return(@openstack_servers)
-      Fog::Compute::OpenStack.should_receive(:new).and_return(@openstack_connection)
-      @bootstrap = Chef::Knife::Bootstrap.new
-      Chef::Knife::Bootstrap.stub(:new).and_return(@bootstrap)
-      @bootstrap.should_receive(:run)
-      @knife_openstack_create.config[:run_list] = []
-      @knife_openstack_create.config[:floating_ip] = '-1'
+  describe "#validate_params!" do
+    before(:each) do
+      @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
+      allow(@instance.ui).to receive(:error)
+      Chef::Config[:knife][:bootstrap_protocol] = "ssh"
+      Chef::Config[:knife][:identity_file] = "identity_file"
+      Chef::Config[:knife][:image_os_type] = "linux"
+      Chef::Config[:knife][:openstack_ssh_key_id] = "openstack_ssh_key"
     end
 
-    it "Creates an OpenStack instance and bootstraps it" do
-      @new_openstack_server.should_receive(:wait_for).and_return(true)
-      @knife_openstack_create.run
+    after(:all) do
+      Chef::Config[:knife].delete(:bootstrap_protocol)
+      Chef::Config[:knife].delete(:identity_file)
+      Chef::Config[:knife].delete(:image_os_type)
+      Chef::Config[:knife].delete(:openstack_ssh_key_id)
     end
 
-    it "Creates an OpenStack instance for Windows and bootstraps it" do
-      @bootstrap_win = Chef::Knife::BootstrapWindowsWinrm.new
-      Chef::Knife::BootstrapWindowsWinrm.stub(:new).and_return(@bootstrap_win)
-      Chef::Config[:knife][:bootstrap_protocol] = 'winrm'
-      @new_openstack_server.should_receive(:wait_for).and_return(true)
-      @knife_openstack_create.run
+    it "run sucessfully on all params exist" do
+      expect { @instance.validate_params! }.to_not raise_error
     end
+  end
 
-    it "creates an OpenStack instance, assigns existing floating ip and bootstraps it" do
-      @knife_openstack_create.config[:floating_ip] = "111.111.111.111"
-      @new_openstack_server.should_receive(:wait_for).and_return(true)
-      @new_openstack_server.should_receive(:associate_address).with('111.111.111.111')
-      @knife_openstack_create.run
+  describe "#before_exec_command" do
+    before(:each) do
+      @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
+      allow(@instance.ui).to receive(:error)
+      @instance.config[:chef_node_name] = "chef_node_name"
+      Chef::Config[:knife][:image] = "image"
+      Chef::Config[:knife][:flavor] = "flavor"
+      Chef::Config[:knife][:openstack_security_groups] = "openstack_security_groups"
+      Chef::Config[:knife][:server_create_timeout] = "server_create_timeout"
+      Chef::Config[:knife][:openstack_ssh_key_id] = "openstack_ssh_key"
+      Chef::Config[:knife][:network_ids] = "test_network_id"
+      allow(Chef::Config[:knife][:network_ids]).to receive(:map).and_return(Chef::Config[:knife][:network_ids])
+      Chef::Config[:knife][:metadata] = "foo=bar"
+    end
+
+    after(:all) do
+      Chef::Config[:knife].delete(:image)
+      Chef::Config[:knife].delete(:flavor)
+      Chef::Config[:knife].delete(:openstack_ssh_key_id)
+      Chef::Config[:knife].delete(:openstack_security_groups)
+      Chef::Config[:knife].delete(:server_create_timeout)
+      Chef::Config[:knife].delete(:metadata)
+    end
+
+    it "set create_options" do
+      @instance.service = double
+      allow(@instance.service).to receive(:get_image).and_return(get_mock_resource('image'))
+      allow(@instance.service).to receive(:get_flavor).and_return(get_mock_resource('flavor'))
+      expect(@instance.service).to receive(:create_server_dependencies)
+      expect(@instance).to receive(:post_connection_validations)
+      @instance.before_exec_command
+      expect(@instance.create_options[:server_def][:name]).to be == @instance.config[:chef_node_name]
+      expect(@instance.create_options[:server_def][:image_ref]).to be == Chef::Config[:knife][:image]
+      expect(@instance.create_options[:server_def][:security_groups]).to be == Chef::Config[:knife][:openstack_security_groups]
+      expect(@instance.create_options[:server_def][:flavor_ref]).to be == Chef::Config[:knife][:flavor]
+      expect(@instance.create_options[:server_def][:nics]).to be == Chef::Config[:knife][:network_ids]
+      expect(@instance.create_options[:server_def][:metadata]).to be == Chef::Config[:knife][:metadata]
+      expect(@instance.create_options[:server_create_timeout]).to be == Chef::Config[:knife][:server_create_timeout]
+    end
+
+    it "doesn't set user data in server_def if user_data not specified" do
+      @instance.service = double("Chef::Knife::Cloud::OpenstackService", :create_server_dependencies => nil)
+      allow(@instance.service).to receive(:get_image).and_return(get_mock_resource('image'))
+      allow(@instance.service).to receive(:get_flavor).and_return(get_mock_resource('flavor'))
+      expect(@instance).to receive(:post_connection_validations)
+      @instance.before_exec_command
+      expect(@instance.create_options[:server_def]).to_not include(:user_data)
+    end
+
+    it "sets user data" do
+      user_data = "echo 'hello world' >> /tmp/user_data.txt"
+      Chef::Config[:knife][:user_data] = user_data
+      @instance.service = double("Chef::Knife::Cloud::OpenstackService", :create_server_dependencies => nil)
+      allow(@instance.service).to receive(:get_image).and_return(get_mock_resource('image'))
+      allow(@instance.service).to receive(:get_flavor).and_return(get_mock_resource('flavor'))
+      expect(@instance).to receive(:post_connection_validations)
+      @instance.before_exec_command
+      expect(@instance.create_options[:server_def][:user_data]).to be == user_data
+    end
+
+    context "with multiple network_ids specified" do
+      before(:each) do
+        @instance.service = double
+        allow(@instance.service).to receive(:get_image).and_return(get_mock_resource('image'))
+        allow(@instance.service).to receive(:get_flavor).and_return(get_mock_resource('flavor'))
+        expect(@instance.service).to receive(:create_server_dependencies)
+        Chef::Config[:knife][:network_ids] = "test_network_id1,test_network_id2"
+        allow(Chef::Config[:knife][:network_ids]).to receive(:map).and_return(Chef::Config[:knife][:network_ids].split(","))
+        expect(@instance).to receive(:post_connection_validations)
+      end
+      
+      it "creates the server_def with multiple nic_ids." do
+        @instance.before_exec_command
+        expect(@instance.create_options[:server_def][:nics]).to be == ["test_network_id1", "test_network_id2"]
+      end
+    end
+
+    it "ensures default value for metadata" do
+      options = @instance.options
+      expect(options[:metadata][:default]).to be == nil
     end
   end
 
-  describe "when configuring the bootstrap process" do
-    before do
-      @knife_openstack_create.config[:ssh_user] = "ubuntu"
-      @knife_openstack_create.config[:ssh_port] = "44"
-      @knife_openstack_create.config[:identity_file] = "~/.ssh/key.pem"
-      @knife_openstack_create.config[:chef_node_name] = "blarf"
-      @knife_openstack_create.config[:template_file] = '~/.chef/templates/my-bootstrap.sh.erb'
-      @knife_openstack_create.config[:distro] = 'ubuntu-10.04-magic-sparkles'
-      @knife_openstack_create.config[:first_boot_attributes] = {'some_var' => true}
-      @knife_openstack_create.config[:run_list] = ['role[base]']
+  describe "#after_exec_command" do
+    before(:each) do
+      @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
+      allow(@instance).to receive(:msg_pair)
+    end
+
+    after(:all) do
+      Chef::Config[:knife].delete(:openstack_floating_ip)
+    end
+
+    it "don't set openstack_floating_ip on missing openstack_floating_ip option" do
+      #default openstack_floating_ip is '-1'
+      Chef::Config[:knife][:openstack_floating_ip] = "-1"
+      @instance.service = Chef::Knife::Cloud::Service.new
+      @instance.server = double
+      expect(@instance.server).to_not receive(:associate_address)
+      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.1.1"}]})
+      expect(@instance).to receive(:bootstrap)
+      @instance.after_exec_command
+    end
+
+    it "set openstack_floating_ip on openstack_floating_ip option" do
+      Chef::Config[:knife][:openstack_floating_ip] = nil
+      @instance.service = Chef::Knife::Cloud::Service.new
+      @instance.server = double
+      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.1.1"}]})
+      expect(@instance).to receive(:bootstrap)
+      connection = double
+      allow(@instance.service).to receive(:connection).and_return(double)
+      free_floating = Object.new
+      free_floating.define_singleton_method(:fixed_ip) { return nil }
+      free_floating.define_singleton_method(:ip) { return "127.0.0.1" }
+      expect(@instance.service.connection).to receive(:addresses).and_return([free_floating])
+      expect(@instance.server).to receive(:associate_address).with(free_floating.ip)
+      @instance.after_exec_command
+    end
+
+    it "raise error on unavailability of free_floating ip" do
+      Chef::Config[:knife][:openstack_floating_ip] = nil
+      @instance.service = Chef::Knife::Cloud::Service.new
+      allow(@instance.ui).to receive(:fatal)
+      @instance.server = double
+      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.1.1"}]})
+      expect(@instance).to_not receive(:bootstrap)
+      connection = double
+      allow(@instance.service).to receive(:connection).and_return(double)
+      free_floating = Object.new
+      free_floating.define_singleton_method(:fixed_ip) { return "127.0.0.1" }
+      expect(@instance.service.connection).to receive(:addresses).and_return([free_floating])
+      expect(@instance.server).to_not receive(:associate_address)
+      expect { @instance.after_exec_command }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ServerSetupError, "Unable to assign a Floating IP from allocated IPs.")
+    end    
+  end
 
-      @bootstrap = @knife_openstack_create.bootstrap_for_node(@new_openstack_server,
-        @new_openstack_server.addresses['public'].last['addr'])
+  describe "#before_bootstrap" do
+    before(:each) do
+      @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
+      @instance.server = double
+      # default bootstrap_network is public
+      @instance.config[:bootstrap_network] = "public"
+      # default no network is true
+      @instance.config[:network] = true
+      Chef::Config[:knife][:ssh_password] = "config_ssh_password"
     end
 
-    it "should set the bootstrap 'name argument' to the hostname of the OpenStack server" do
-      @bootstrap.name_args.should == ['75.101.253.10']
+    after(:each) do
+      Chef::Config[:knife].delete(:ssh_password)
     end
 
-    it "configures sets the bootstrap's run_list" do
-      @bootstrap.config[:run_list].should == ['role[base]']
+    context "when no-network option specified" do
+      before(:each) { @instance.config[:network] = false }
+
+      it "set public ip as a bootstrap ip if both public and private ip available" do
+        allow(@instance.server).to receive(:addresses).and_return({"private"=>[{"version"=>4, "addr"=>"127.0.0.1"}], "public"=>[{"version"=>4, "addr"=>"127.0.0.2"}]})
+        @instance.before_bootstrap
+        expect(@instance.config[:bootstrap_ip_address]).to be == "127.0.0.2"
+      end
+
+      it "set private-ip as a bootstrap ip if private ip is available" do
+        allow(@instance.server).to receive(:addresses).and_return({"private"=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
+        @instance.before_bootstrap
+        expect(@instance.config[:bootstrap_ip_address]).to be == "127.0.0.1"
+      end
+
+      it "set available ip as a bootstrap ip if no public, private ip available" do
+        allow(@instance.server).to receive(:addresses).and_return({1=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
+        @instance.before_bootstrap
+        expect(@instance.config[:bootstrap_ip_address]).to be == "127.0.0.1"
+      end
     end
 
-    it "configures the bootstrap to use the correct ssh_user login" do
-      @bootstrap.config[:ssh_user].should == 'ubuntu'
+    it "set bootstrap_ip" do
+      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
+      @instance.before_bootstrap
+      expect(@instance.config[:bootstrap_ip_address]).to be == "127.0.0.1"
     end
 
-    it "configures the bootstrap to use the correct ssh_port" do
-      @bootstrap.config[:ssh_port].should == '44'
+    it "set private-ip as a bootstrap-ip if private-network option set" do
+      allow(@instance.server).to receive(:addresses).and_return({"private"=>[{"version"=>4, "addr"=>"127.0.0.1"}], "public"=>[{"version"=>4, "addr"=>"127.0.0.2"}]})
+      @instance.config[:private_network] = true
+      @instance.before_bootstrap
+      expect(@instance.config[:bootstrap_ip_address]).to be == "127.0.0.1"
     end
 
-    it "configures the bootstrap to use the correct ssh identity file" do
-      @bootstrap.config[:identity_file].should == "~/.ssh/key.pem"
+    it "raise error on nil bootstrap_ip" do
+      allow(@instance.ui).to receive(:error)
+
+      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>nil}]})
+      expect { @instance.before_bootstrap }.to raise_error(Chef::Knife::Cloud::CloudExceptions::BootstrapError, "No IP address available for bootstrapping.")
+    end
+    
+    it "set public ip as default bootstrap network is public" do
+      allow(@instance.server).to receive(:addresses).and_return({"private"=>[{"version"=>4, "addr"=>"127.0.0.1"}], "public"=>[{"version"=>4, "addr"=>"127.0.0.2"}]})
+      @instance.before_bootstrap
+      expect(@instance.config[:bootstrap_ip_address]).to be == "127.0.0.2"
     end
 
-    it "configures the bootstrap to use the configured node name if provided" do
-      @bootstrap.config[:chef_node_name].should == 'blarf'
+    it "configures the bootstrap to use alternate network" do
+      allow(@instance.server).to receive(:addresses).and_return({"foo"=>[{"version"=>1, "addr"=>"127.0.0.1"}], "private"=>[{"version"=>4, "addr"=>"127.0.0.2"}], "public"=>[{"version"=>4, "addr"=>"127.0.0.3"}]})
+      @instance.config[:bootstrap_network] = 'foo'
+      @instance.before_bootstrap
+      expect(@instance.config[:bootstrap_ip_address]).to be == "127.0.0.1"
     end
 
     it "configures the bootstrap to use the server password" do
-      @bootstrap.config[:ssh_password].should == 'password'
+      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
+      Chef::Config[:knife].delete(:ssh_password)
+      server_password  = "adFRjk1089"
+      allow(@instance.server).to receive(:password).and_return(server_password)
+      @instance.before_bootstrap
+      expect(@instance.config[:ssh_password]).to be == server_password
     end
 
     it "configures the bootstrap to use the config ssh password" do
-      @knife_openstack_create.config[:ssh_password] = 'testing123'
-
-      bootstrap = @knife_openstack_create.bootstrap_for_node(@new_openstack_server,
-        @new_openstack_server.addresses['public'].last['addr'])
+      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
+      server_password  = "config_ssh_password"
+      Chef::Config[:knife][:ssh_password] = server_password
+      expect(@instance.server).to_not receive(:password)
+      @instance.before_bootstrap
+      expect(@instance.config[:ssh_password]).to be == server_password
+    end    
+  end
 
-      bootstrap.config[:ssh_password].should == 'testing123'
+  describe "#post_connection_validations" do
+    before(:each) do
+      @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
+      allow(@instance.ui).to receive(:error)
     end
 
-    it "configures the bootstrap to use the OpenStack server id if no explicit node name is set" do
-      @knife_openstack_create.config[:chef_node_name] = nil
-
-      bootstrap = @knife_openstack_create.bootstrap_for_node(@new_openstack_server,
-        @new_openstack_server.addresses['public'].last['addr'])
-      bootstrap.config[:chef_node_name].should == @new_openstack_server.name
+    it "raise error on invalid image" do
+      allow(@instance).to receive(:is_flavor_valid?).and_return(true)
+      allow(@instance).to receive(:is_floating_ip_valid?).and_return(true)
+      expect(@instance).to receive(:is_image_valid?).and_return(false)
+      expect { @instance.post_connection_validations }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ValidationError, " You have not provided a valid image ID. Please note the options for this value are -I or --image..")
     end
 
-    it "configures the bootstrap to use prerelease versions of chef if specified" do
-      @bootstrap.config[:prerelease].should be_false
-
-      @knife_openstack_create.config[:prerelease] = true
-
-      bootstrap = @knife_openstack_create.bootstrap_for_node(@new_openstack_server,
-        @new_openstack_server.addresses['public'].last['addr'])
-      bootstrap.config[:prerelease].should be_true
+    it "raise error on invalid flavor" do
+      allow(@instance).to receive(:is_image_valid?).and_return(true)
+      allow(@instance).to receive(:is_floating_ip_valid?).and_return(true)
+      expect(@instance).to receive(:is_flavor_valid?).and_return(false)
+      expect { @instance.post_connection_validations }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ValidationError, " You have not provided a valid flavor ID. Please note the options for this value are -f or --flavor..")
     end
 
-    it "configures the bootstrap to use the desired distro-specific bootstrap script" do
-      @bootstrap.config[:distro].should == 'ubuntu-10.04-magic-sparkles'
+    it "raise error on invalid floating IP" do
+      allow(@instance).to receive(:is_flavor_valid?).and_return(true)
+      allow(@instance).to receive(:is_image_valid?).and_return(true)      
+      expect(@instance).to receive(:is_floating_ip_valid?).and_return(false)
+      expect { @instance.post_connection_validations }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ValidationError, " You have either requested an invalid floating IP address or none are available..")
     end
+  end
 
-    it "configures the bootstrap to use sudo" do
-      @bootstrap.config[:use_sudo].should be_true
+  describe "#is_floating_ip_valid?" do
+    before(:each) do
+      @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
+      # Default value
+      Chef::Config[:knife][:openstack_floating_ip] = "-1"
+      @instance.service = double
     end
 
-    it "configures the bootstrap with json attributes" do
-      @bootstrap.config[:first_boot_attributes]['some_var'].should be_true
+    after(:all) do
+      Chef::Config[:knife].delete(:openstack_floating_ip)
     end
 
-    it "configured the bootstrap to use the desired template" do
-      @bootstrap.config[:template_file].should == '~/.chef/templates/my-bootstrap.sh.erb'
+    it "returns true for default" do
+      expect(@instance.is_floating_ip_valid?).to be true
     end
 
-    it "configured the bootstrap to set an openstack hint (via Chef::Config)" do
-      Chef::Config[:knife][:hints]['openstack'].should_not be_nil
+    it "returns false if no floating IPs" do
+      Chef::Config[:knife].delete(:openstack_floating_ip)
+      expect(@instance.service).to receive_message_chain(:connection, :addresses).and_return([])
+      expect(@instance.is_floating_ip_valid?).to be false
+    end
+    
+    context "when floating ip requested without value" do
+      it "returns true if fixed_ip is nil" do
+        Chef::Config[:knife][:openstack_floating_ip] = nil
+        obj = Object.new
+        obj.define_singleton_method(:fixed_ip){nil}
+        expect(@instance.service).to receive_message_chain(:connection, :addresses).and_return([obj])
+        expect(@instance.is_floating_ip_valid?).to be true
+      end
     end
-  end
 
-  describe "when configuring the bootstrap process with private networks" do
-    before do
-      @knife_openstack_create.config[:private_network] = true
+    context "when floating ip requested with value" do
+      before {Chef::Config[:knife][:openstack_floating_ip] = "127.0.0.1"}
+      after {Chef::Config[:knife].delete(:openstack_floating_ip)}
 
-      @bootstrap = @knife_openstack_create.bootstrap_for_node(@new_openstack_server,
-        @new_openstack_server.addresses['private'].last['addr'])
-    end
+      it "returns true if requested floating IP is exist" do
+        obj = Object.new
+        obj.define_singleton_method(:ip){return "127.0.0.1"}
+        expect(@instance.service).to receive_message_chain(:connection, :addresses).and_return([obj])
+        expect(@instance.is_floating_ip_valid?).to be true
+      end
 
-    it "configures the bootstrap to use private network" do
-      @bootstrap.name_args.should == ['10.251.75.20']
+      it "returns false if requested floating IP does not exist" do
+        obj = Object.new
+        obj.define_singleton_method(:ip){return "127.0.1.1"}
+        expect(@instance.service).to receive_message_chain(:connection, :addresses).and_return([obj])
+        expect(@instance.is_floating_ip_valid?).to be false
+      end
     end
   end
 
-  describe "when configuring the bootstrap process with alternate networks" do
-    before do
-      @knife_openstack_create.config[:bootstrap_network] = 'foo'
+  describe "#is_image_valid?" do
+    before(:each) do
+      @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
+      @instance.service = double
+      Chef::Config[:knife][:image] = "image_id"
+    end
 
-      @bootstrap = @knife_openstack_create.bootstrap_for_node(@new_openstack_server,
-        @new_openstack_server.addresses['foo'].last['addr'])
+    after(:each) do
+      Chef::Config[:knife].delete(:image)
     end
 
-    it "configures the bootstrap to use alternate network" do
-      @bootstrap.name_args.should == ['34.56.78.90']
+    it "returns false on invalid image" do
+      expect(@instance.service).to receive_message_chain(:get_image).and_return(nil)
+      expect(@instance.is_image_valid?).to be false
+    end
+
+    it "returns true on valid image" do
+      expect(@instance.service).to receive_message_chain(:get_image).and_return("image")
+      expect(@instance.is_image_valid?).to be true
     end
   end
 
-  describe "when configuring the bootstrap process with no networks" do
-    before do
-      @knife_openstack_create.config[:network] = false
+  describe "#is_flavor_valid?" do
+    before(:each) do
+      @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
+      @instance.service = double
+      Chef::Config[:knife][:flavor] = "flavor"
+    end
 
-      @bootstrap = @knife_openstack_create.bootstrap_for_node(@new_openstack_server,
-        @new_openstack_server.addresses['public'].last['addr'])
+    after(:each) do
+      Chef::Config[:knife].delete(:flavor)
+    end
+    
+    it "returns false on invalid flavor" do
+      expect(@instance.service).to receive_message_chain(:get_flavor).and_return(nil)
+      expect(@instance.is_flavor_valid?).to be false
     end
 
-    it "configures the bootstrap to use public network since none specified" do
-      @bootstrap.name_args.should == ['75.101.253.10']
+    it "returns true on valid flavor" do
+      expect(@instance.service).to receive_message_chain(:get_flavor).and_return("flavor")
+      expect(@instance.is_flavor_valid?).to be true
     end
   end
 end