knife-openstack 1.3.2.pre → 1.3.2.pre.1

data/spec/spec_context.rb

@@ -15,12 +15,12 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-shared_context  "#validate!" do |instance|
+shared_context '#validate!' do |instance|
   before(:each) do
-    Chef::Config[:knife][:openstack_username] = "testuser"
-    Chef::Config[:knife][:openstack_password] = "testpassword"
-    Chef::Config[:knife][:openstack_auth_url] = "tsturl"
-    Chef::Config[:knife][:openstack_region] = "test-region"
+    Chef::Config[:knife][:openstack_username] = 'testuser'
+    Chef::Config[:knife][:openstack_password] = 'testpassword'
+    Chef::Config[:knife][:openstack_auth_url] = 'tsturl'
+    Chef::Config[:knife][:openstack_region] = 'test-region'
     allow(instance).to receive(:exit)
   end
 
@@ -31,23 +31,23 @@ shared_context  "#validate!" do |instance|
     Chef::Config[:knife].delete(:openstack_region)
   end
 
-  it "validate openstack mandatory options" do
-    expect {instance.validate!}.to_not raise_error
+  it 'validate openstack mandatory options' do
+    expect { instance.validate! }.to_not raise_error
   end
 
-  it "raise error on openstack_username missing" do
+  it 'raise error on openstack_username missing' do
     Chef::Config[:knife].delete(:openstack_username)
     expect(instance.ui).to receive(:error).with("You did not provide a valid 'Openstack Username' value.")
     expect { instance.validate! }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ValidationError)
   end
 
-  it "raise error on openstack_password missing" do
+  it 'raise error on openstack_password missing' do
     Chef::Config[:knife].delete(:openstack_password)
     expect(instance.ui).to receive(:error).with("You did not provide a valid 'Openstack Password' value.")
     expect { instance.validate! }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ValidationError)
   end
 
-  it "raise error on openstack_auth_url missing" do
+  it 'raise error on openstack_auth_url missing' do
     Chef::Config[:knife].delete(:openstack_auth_url)
     expect(instance.ui).to receive(:error).with("You did not provide a valid 'Openstack Auth Url' value.")
     expect { instance.validate! }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ValidationError)

data/spec/spec_helper.rb

@@ -15,8 +15,7 @@
 
 # Author:: Siddheshwar More (<siddheshwar.more@clogeny.com>)
 
-
-$:.unshift File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
 require 'chef/knife/bootstrap'
 require 'chef/knife/openstack_helpers'
 require 'fog'
@@ -25,7 +24,7 @@ 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 'securerandom'
 require 'knife-openstack/version'
 require 'test/knife-utils/test_bed'
 require 'resource_spec_helper'
@@ -35,14 +34,12 @@ require 'spec_context'
 
 def find_instance_id(instance_name, file)
   file.lines.each do |line|
-    if line.include?("#{instance_name}")
-      return "#{line}".split(" ")[2].strip
-    end
+    return "#{line}".split(' ')[2].strip if line.include?("#{instance_name}")
   end
 end
 
 def is_config_present
-  if ! ENV['RUN_INTEGRATION_TESTS']
+  unless ENV['RUN_INTEGRATION_TESTS']
     puts("\nPlease set RUN_INTEGRATION_TESTS environment variable to run integration tests")
     return false
   end
@@ -50,17 +47,17 @@ def is_config_present
   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
+  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
+    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."
+  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|
@@ -72,38 +69,37 @@ def is_config_present
   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."
+  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"
+  '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"
+  '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)}"
+  @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)}
+    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"
+    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
+  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])
@@ -112,9 +108,9 @@ def init_openstack_test
     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)}
+    File.open("#{temp_dir}/openstack.pem", 'w') { |f| f.write(data_to_write) }
   rescue
-    puts "Error while creating file - openstack.pem"
+    puts 'Error while creating file - openstack.pem'
   end
 end
 

data/spec/unit/openstack_flavor_list_spec.rb

@@ -25,5 +25,5 @@ require 'support/shared_examples_for_command'
 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
+  include_context '#validate!', Chef::Knife::Cloud::OpenstackFlavorList.new
 end

data/spec/unit/openstack_floating_ip_allocate_spec.rb

@@ -21,7 +21,6 @@ require 'chef/knife/cloud/openstack_service'
 require 'support/shared_examples_for_command'
 
 describe Chef::Knife::Cloud::OpenstackFloatingIpAllocate do
-
   it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::OpenstackFloatingIpAllocate.new
   include_context '#validate!', Chef::Knife::Cloud::OpenstackFloatingIpAllocate.new
 
@@ -46,9 +45,9 @@ describe Chef::Knife::Cloud::OpenstackFloatingIpAllocate do
 
   describe 'when user provides pool option ' do
     it 'allocates floating ip in user specified pool' do
-      @instance = Chef::Knife::Cloud::OpenstackFloatingIpAllocate.new(["--pool", "test-pool"])
+      @instance = Chef::Knife::Cloud::OpenstackFloatingIpAllocate.new(['--pool', 'test-pool'])
       @instance.service = Chef::Knife::Cloud::Service.new
-      response = {:floating_ip => {'id' => 'test-id', 'instance_id' => 'test-instance-id', 'floating_ip' => '127.0.0.1', 'fixed_ip' => 'nil', 'pool' => 'test-pool' }}
+      response = { floating_ip: { 'id' => 'test-id', 'instance_id' => 'test-instance-id', 'floating_ip' => '127.0.0.1', 'fixed_ip' => 'nil', 'pool' => 'test-pool' } }
       expect(@instance.service).to receive(:allocate_address).and_return(response)
       @instance.execute_command
     end

data/spec/unit/openstack_floating_ip_associate_spec.rb

@@ -22,8 +22,8 @@ require 'ostruct'
 
 describe Chef::Knife::Cloud::OpenstackFloatingIpAssociate do
   before(:each) do
-    @instance = Chef::Knife::Cloud::OpenstackFloatingIpAssociate.new(["--instance-id", "23849038438240934n3294839248"])
-    @instance.name_args = [ '127.0.0.1' ]
+    @instance = Chef::Knife::Cloud::OpenstackFloatingIpAssociate.new(['--instance-id', '23849038438240934n3294839248'])
+    @instance.name_args = ['127.0.0.1']
   end
 
   describe 'associate floating ip' do

data/spec/unit/openstack_floating_ip_disassociate_spec.rb

@@ -22,14 +22,14 @@ require 'ostruct'
 
 describe Chef::Knife::Cloud::OpenstackFloatingIpDisassociate do
   before(:each) do
-    @instance = Chef::Knife::Cloud::OpenstackFloatingIpDisassociate.new(["--instance-id", "23849038438240934n3294839248"])
-    @instance.name_args = [ '127.0.0.1' ]
+    @instance = Chef::Knife::Cloud::OpenstackFloatingIpDisassociate.new(['--instance-id', '23849038438240934n3294839248'])
+    @instance.name_args = ['127.0.0.1']
   end
 
   describe 'associate floating ip' do
     it 'calls associate address' do
       @instance.service = Chef::Knife::Cloud::Service.new
-      response = OpenStruct.new(:status => 202)
+      response = OpenStruct.new(status: 202)
       expect(@instance.service).to receive(:disassociate_address).with('23849038438240934n3294839248', '127.0.0.1').and_return(response)
       expect(@instance.ui).to receive(:info).and_return('Floating IP 127.0.0.1 disassociated with Instance 23849038438240934n3294839248')
       @instance.execute_command

data/spec/unit/openstack_floating_ip_release_spec.rb

@@ -26,7 +26,7 @@ describe Chef::Knife::Cloud::OpenstackFloatingIpRelease do
   before(:each) do
     @instance = Chef::Knife::Cloud::OpenstackFloatingIpRelease.new
     allow(@instance.ui).to receive(:error)
-    @instance.name_args = [ '23849038438240934n3294839248' ]
+    @instance.name_args = ['23849038438240934n3294839248']
   end
 
   describe 'create service instance' do

data/spec/unit/openstack_group_list_spec.rb

@@ -25,18 +25,18 @@ require 'support/shared_examples_for_command'
 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
+  include_context '#validate!', Chef::Knife::Cloud::OpenstackGroupList.new
 
-  let (:instance) {Chef::Knife::Cloud::OpenstackGroupList.new}
+  let (:instance) { Chef::Knife::Cloud::OpenstackGroupList.new }
 
-  context "#list" do
+  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})]})]
-      instance.config[:format] = "summary"
+      @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)])]
+      instance.config[:format] = 'summary'
     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)
+    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

data/spec/unit/openstack_image_list_spec.rb

@@ -25,7 +25,7 @@ require 'support/shared_examples_for_command'
 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}
+  let (:instance) { Chef::Knife::Cloud::OpenstackImageList.new }
 
-  include_context "#validate!", Chef::Knife::Cloud::OpenstackImageList.new
+  include_context '#validate!', Chef::Knife::Cloud::OpenstackImageList.new
 end

data/spec/unit/openstack_network_list_spec.rb

@@ -24,12 +24,12 @@ require 'support/shared_examples_for_command'
 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}
+  let (:instance) { Chef::Knife::Cloud::OpenstackNetworkList.new }
 
-  include_context "#validate!", 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
+  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

data/spec/unit/openstack_server_create_spec.rb

@@ -18,7 +18,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-
 require File.expand_path('../../spec_helper', __FILE__)
 require 'chef/knife/openstack_server_create'
 require 'support/shared_examples_for_servercreatecommand'
@@ -26,34 +25,34 @@ require 'support/shared_examples_for_command'
 
 describe Chef::Knife::Cloud::OpenstackServerCreate do
   create_instance = Chef::Knife::Cloud::OpenstackServerCreate.new
-  create_instance.define_singleton_method(:post_connection_validations){}
+  create_instance.define_singleton_method(:post_connection_validations) {}
 
   it_behaves_like Chef::Knife::Cloud::Command, Chef::Knife::Cloud::OpenstackServerCreate.new
   it_behaves_like Chef::Knife::Cloud::ServerCreateCommand, create_instance
 
-  describe "#create_service_instance" do
+  describe '#create_service_instance' do
     before(:each) do
       @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
     end
 
-    it "return OpenstackService instance" do
+    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
+    it 'has custom_arguments as its option' do
       expect(@instance.options.include? :custom_attributes).to be true
-     end
+    end
   end
 
-  describe "#validate_params!" do
+  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"
-      Chef::Config[:knife][:openstack_region] = "test-region"
+      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'
+      Chef::Config[:knife][:openstack_region] = 'test-region'
     end
 
     after(:all) do
@@ -64,24 +63,24 @@ describe Chef::Knife::Cloud::OpenstackServerCreate do
       Chef::Config[:knife].delete(:openstack_region)
     end
 
-    it "run sucessfully on all params exist" do
+    it 'run sucessfully on all params exist' do
       expect { @instance.validate_params! }.to_not raise_error
     end
   end
 
-  describe "#before_exec_command" do
+  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"
+      @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"
+      Chef::Config[:knife][:metadata] = 'foo=bar'
     end
 
     after(:all) do
@@ -93,7 +92,7 @@ describe Chef::Knife::Cloud::OpenstackServerCreate do
       Chef::Config[:knife].delete(:metadata)
     end
 
-    it "set create_options" do
+    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'))
@@ -111,7 +110,7 @@ describe Chef::Knife::Cloud::OpenstackServerCreate do
     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)
+      @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)
@@ -119,10 +118,10 @@ describe Chef::Knife::Cloud::OpenstackServerCreate do
       expect(@instance.create_options[:server_def]).to_not include(:user_data)
     end
 
-    it "sets user data" do
+    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)
+      @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)
@@ -130,30 +129,30 @@ describe Chef::Knife::Cloud::OpenstackServerCreate do
       expect(@instance.create_options[:server_def][:user_data]).to be == user_data
     end
 
-    context "with multiple network_ids specified" do
+    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(","))
+        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
+      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"]
+        expect(@instance.create_options[:server_def][:nics]).to be == %w(test_network_id1 test_network_id2)
       end
     end
 
-    it "ensures default value for metadata" do
+    it 'ensures default value for metadata' do
       options = @instance.options
-      expect(options[:metadata][:default]).to be == nil
+      expect(options[:metadata][:default]).to be.nil?
     end
   end
 
-  describe "#after_exec_command" do
+  describe '#after_exec_command' do
     before(:each) do
       @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
       allow(@instance).to receive(:msg_pair)
@@ -164,16 +163,16 @@ describe Chef::Knife::Cloud::OpenstackServerCreate do
     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"
+      # default openstack_floating_ip is '-1'
+      Chef::Config[:knife][:openstack_floating_ip] = '-1'
       @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"}]})
+      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
+    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
@@ -181,120 +180,120 @@ describe Chef::Knife::Cloud::OpenstackServerCreate do
       @network = double
       @ports = ['id' => 'test',
                 'fixed_ips' => ['ip_address' => '127.0.1.1']]
-      allow(@network).to receive(:list_ports).and_return(body: {'ports' => @ports})
+      allow(@network).to receive(:list_ports).and_return(body: { 'ports' => @ports })
       @floating_ips = ['id' => 'test',
-                'fixed_ips' => ['ip_address' => '127.0.1.1']]
-      allow(@network).to receive(:list_floating_ips).and_return(body: {'floatingips' => @floating_ips})
+                       'fixed_ips' => ['ip_address' => '127.0.1.1']]
+      allow(@network).to receive(:list_floating_ips).and_return(body: { 'floatingips' => @floating_ips })
       allow(@network).to receive(:associate_floating_ip)
       allow(@instance.service).to receive(:network).and_return(@network)
 
-      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.1.1"}]})
+      allow(@instance.server).to receive(:addresses).and_return({ 'public' => [{ 'version' => 4, 'addr' => '127.0.1.1' }] })
       expect(@instance).to receive(:bootstrap)
       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" }
+      free_floating.define_singleton_method(:ip) { return '127.0.0.1' }
       expect(@instance.service.connection).to receive(:addresses).and_return([free_floating])
       @instance.after_exec_command
     end
 
-    it "raise error on unavailability of free_floating ip" do
+    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"}]})
+      allow(@instance.server).to receive(:addresses).and_return({ 'public' => [{ 'version' => 4, 'addr' => '127.0.1.1' }] })
       expect(@instance).to_not receive(:bootstrap)
       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" }
+      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.after_exec_command }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ServerSetupError, "Unable to assign a Floating IP from allocated IPs.")
+      expect { @instance.after_exec_command }.to raise_error(Chef::Knife::Cloud::CloudExceptions::ServerSetupError, 'Unable to assign a Floating IP from allocated IPs.')
     end
   end
 
-  describe "#before_bootstrap" do
+  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"
+      @instance.config[:bootstrap_network] = 'public'
       # default no network is true
       @instance.config[:network] = true
-      Chef::Config[:knife][:ssh_password] = "config_ssh_password"
+      Chef::Config[:knife][:ssh_password] = 'config_ssh_password'
     end
 
     after(:each) do
       Chef::Config[:knife].delete(:ssh_password)
     end
 
-    context "when no-network option specified" do
+    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"}]})
+      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"
+        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"}]})
+      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"
+        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"}]})
+      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"
+        expect(@instance.config[:bootstrap_ip_address]).to be == '127.0.0.1'
       end
     end
 
-    it "set bootstrap_ip" do
-      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
+    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"
+      expect(@instance.config[:bootstrap_ip_address]).to be == '127.0.0.1'
     end
 
-    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"}]})
+    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"
+      expect(@instance.config[:bootstrap_ip_address]).to be == '127.0.0.1'
     end
 
-    it "raise error on nil bootstrap_ip" do
+    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.")
+      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"}]})
+    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"
+      expect(@instance.config[:bootstrap_ip_address]).to be == '127.0.0.2'
     end
 
-    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"}]})
+    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"
+      expect(@instance.config[:bootstrap_ip_address]).to be == '127.0.0.1'
     end
 
-    it "configures the bootstrap to use the server password" do
-      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
+    it 'configures the bootstrap to use the server password' do
+      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"
+      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
-      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
-      server_password  = "config_ssh_password"
+    it 'configures the bootstrap to use the config ssh password' do
+      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
@@ -302,60 +301,60 @@ describe Chef::Knife::Cloud::OpenstackServerCreate do
     end
 
     it "configures the default private bootstrap network to use 'private'" do
-      allow(@instance.server).to receive(:addresses).and_return({"private"=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
+      allow(@instance.server).to receive(:addresses).and_return({ 'private' => [{ 'version' => 4, 'addr' => '127.0.0.1' }] })
       @instance.config[:private_network] = true
       @instance.before_bootstrap
       expect(@instance.config[:bootstrap_network]).to be == 'private'
     end
 
-    it "configures the bootstrap to use alternate private network" do
-      allow(@instance.server).to receive(:addresses).and_return({"secure"=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
+    it 'configures the bootstrap to use alternate private network' do
+      allow(@instance.server).to receive(:addresses).and_return({ 'secure' => [{ 'version' => 4, 'addr' => '127.0.0.1' }] })
       @instance.config[:bootstrap_network] = 'secure'
       @instance.config[:private_network] = true
       @instance.before_bootstrap
       expect(@instance.config[:bootstrap_network]).to be == 'secure'
     end
 
-    it "set openstack ohai hint" do
-      allow(@instance.server).to receive(:addresses).and_return({"public"=>[{"version"=>4, "addr"=>"127.0.0.1"}]})
+    it 'set openstack ohai hint' do
+      allow(@instance.server).to receive(:addresses).and_return({ 'public' => [{ 'version' => 4, 'addr' => '127.0.0.1' }] })
       @instance.before_bootstrap
-      expect(@instance.config[:hints]).to be == {'openstack' => {}}
+      expect(@instance.config[:hints]).to be == { 'openstack' => {} }
     end
   end
 
-  describe "#post_connection_validations" do
+  describe '#post_connection_validations' do
     before(:each) do
       @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
       allow(@instance.ui).to receive(:error)
     end
 
-    it "raise error on invalid image" do
+    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..")
+      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 "raise error on invalid flavor" do
+    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..")
+      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 "raise error on invalid floating IP" do
+    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..")
+      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
 
-  describe "#is_floating_ip_valid?" do
+  describe '#is_floating_ip_valid?' do
     before(:each) do
       @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
       # Default value
-      Chef::Config[:knife][:openstack_floating_ip] = "-1"
+      Chef::Config[:knife][:openstack_floating_ip] = '-1'
       @instance.service = double
     end
 
@@ -363,86 +362,86 @@ describe Chef::Knife::Cloud::OpenstackServerCreate do
       Chef::Config[:knife].delete(:openstack_floating_ip)
     end
 
-    it "returns true for default" do
+    it 'returns true for default' do
       expect(@instance.is_floating_ip_valid?).to be true
     end
 
-    it "returns false if no floating IPs" do
+    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
+    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}
+        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
 
-    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)}
+    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) }
 
-      it "returns true if requested floating IP is exist" do
+      it 'returns true if requested floating IP is exist' do
         obj = Object.new
-        obj.define_singleton_method(:ip){return "127.0.0.1"}
+        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 "returns false if requested floating IP does not exist" do
+      it 'returns false if requested floating IP does not exist' do
         obj = Object.new
-        obj.define_singleton_method(:ip){return "127.0.1.1"}
+        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 "#is_image_valid?" do
+  describe '#is_image_valid?' do
     before(:each) do
       @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
       @instance.service = double
-      Chef::Config[:knife][:image] = "image_id"
+      Chef::Config[:knife][:image] = 'image_id'
     end
 
     after(:each) do
       Chef::Config[:knife].delete(:image)
     end
 
-    it "returns false on invalid image" do
+    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")
+    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 "#is_flavor_valid?" do
+  describe '#is_flavor_valid?' do
     before(:each) do
       @instance = Chef::Knife::Cloud::OpenstackServerCreate.new
       @instance.service = double
-      Chef::Config[:knife][:flavor] = "flavor"
+      Chef::Config[:knife][:flavor] = 'flavor'
     end
 
     after(:each) do
       Chef::Config[:knife].delete(:flavor)
     end
 
-    it "returns false on invalid flavor" do
+    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 "returns true on valid flavor" do
-      expect(@instance.service).to receive_message_chain(:get_flavor).and_return("flavor")
+    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