kitchen-openstack 1.5.2 → 1.5.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: dabecabfd7d572a681fb2a9ea51dcf01c3da1113
-  data.tar.gz: 50c2d3cce5b1ec2ce75e15c798fc97e9dabef0d3
+  metadata.gz: 7616b4cab10679974a5948b4136caa7740e88154
+  data.tar.gz: 5fde868ddac4a5d8c64cc8b21d2cade8821588c6
 SHA512:
-  metadata.gz: cfc8a647b20323221b6f6fb583f3d1b14a807fe8c2c0463e49b96046f97f43422f35204ba97146f5a4eacbd2935a284c9aa2b3f370c74f6c75d823f92e198478
-  data.tar.gz: fc1505ee21df47332240e176753c66bde27628af421c598fefdee31f0a56c6f5af1eaa381fbcde465866d243219547310e88bc6a53c0b25282ba3069e604eace
+  metadata.gz: b39b884a8057e61c4891a7438a866aa6651372e65baf6a0e899a6ad96dc5e0737916dbc6314e0494ab4463d81d3244325677fc12d9a67f2d067755171d1a49d8
+  data.tar.gz: fcc37f270a4c08495604f6d5efcc0882c1056ae7e6626373107261f6de4d4f71f81254598479a33c4b527d1fe7f484e10d285deebd91923eb5f706e5be754c93

data/.rubocop.yml

@@ -0,0 +1,8 @@
+CyclomaticComplexity:
+  Enabled: false
+MethodLength:
+  Enabled: false
+ClassLength:
+  Enabled: false
+ClassVars:
+  Enabled: false

data/.travis.yml

@@ -7,5 +7,4 @@ rvm:
   - 1.9.2
   - 1.9.3
   - 2.0.0
-
-# vim: ai et ts=2 sts=2 sw=2 ft=yaml
+  - 2.1.1

data/CHANGELOG.md

@@ -1,3 +1,8 @@
+# 1.5.3 / 2014-08-01
+
+* PR [#53][] - Rework how server names are generated, disallowing possibly
+error-causing punctuation in resultant names
+
 # 1.5.2 / 2014-05-31
 
 ### Bug Fixes
@@ -101,6 +106,7 @@ certain specified NICs; via [@monsterzz][]
 
 * Initial release! Woo!
 
+[#53]: https://github.com/test-kitchen/kitchen-openstack/pull/53
 [#50]: https://github.com/test-kitchen/kitchen-openstack/pull/50
 [#49]: https://github.com/test-kitchen/kitchen-openstack/pull/49
 [#48]: https://github.com/test-kitchen/kitchen-openstack/pull/48

data/README.md

@@ -34,7 +34,7 @@ Provide, at a minimum, the required driver options in your `.kitchen.yml` file:
       openstack_username: [YOUR OPENSTACK USERNAME]
       openstack_api_key: [YOUR OPENSTACK API KEY]
       openstack_auth_url: [YOUR OPENSTACK AUTH URL]
-      require_chef_omnibus: latest (if you'll be using Chef)
+      require_chef_omnibus: [e.g. 'true' or a version number if you need Chef]
       image_ref: [SERVER IMAGE ID]
       flavor_ref: [SERVER FLAVOR ID]
 

data/Rakefile

@@ -1,15 +1,13 @@
 # Encoding: UTF-8
 
 require 'bundler/setup'
-require 'tailor/rake_task'
+require 'rubocop/rake_task'
 require 'cane/rake_task'
 require 'rspec/core/rake_task'
 
 Cane::RakeTask.new
 
-Tailor::RakeTask.new do |task|
-  task.file_set '**/*.rb'
-end
+RuboCop::RakeTask.new
 
 desc 'Display LOC stats'
 task :loc do
@@ -19,4 +17,4 @@ end
 
 RSpec::Core::RakeTask.new(:spec)
 
-task :default => [ :cane, :tailor, :loc, :spec ]
+task default: [:cane, :rubocop, :loc, :spec]

data/kitchen-openstack.gemspec

@@ -9,14 +9,14 @@ Gem::Specification.new do |spec|
   spec.version       = Kitchen::Driver::OPENSTACK_VERSION
   spec.authors       = ['Jonathan Hartman']
   spec.email         = ['j@p4nt5.com']
-  spec.description   = %q{A Test Kitchen OpenStack Nova driver}
+  spec.description   = 'A Test Kitchen OpenStack Nova driver'
   spec.summary       = spec.description
   spec.homepage      = 'https://github.com/test-kitchen/kitchen-openstack'
   spec.license       = 'Apache'
 
-  spec.files         = `git ls-files`.split($/)
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
   spec.require_paths = ['lib']
 
   spec.add_dependency 'test-kitchen', '~> 1.1'
@@ -27,7 +27,7 @@ Gem::Specification.new do |spec|
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'
-  spec.add_development_dependency 'tailor'
+  spec.add_development_dependency 'rubocop'
   spec.add_development_dependency 'cane'
   spec.add_development_dependency 'countloc'
   spec.add_development_dependency 'rspec'

data/lib/kitchen/driver/openstack.rb

@@ -34,10 +34,10 @@ module Kitchen
 
       default_config :server_name, nil
       default_config :key_name, nil
-      default_config :private_key_path do |driver|
-        %w{id_rsa id_dsa}.collect do |k|
+      default_config :private_key_path do
+        %w(id_rsa id_dsa).map do |k|
           f = File.expand_path "~/.ssh/#{k}"
-          f if File.exists? f
+          f if File.exist?(f)
         end.compact.first
       end
       default_config :public_key_path do |driver|
@@ -57,11 +57,15 @@ module Kitchen
 
       def create(state)
         config[:server_name] ||= generate_name(instance.name)
-        config[:disable_ssl_validation] and disable_ssl_validation
+        config[:disable_ssl_validation] && disable_ssl_validation
         server = create_server
         state[:server_id] = server.id
         info "OpenStack instance <#{state[:server_id]}> created."
-        server.wait_for { print '.'; ready? } ; info "\n(server ready)"
+        server.wait_for do
+          print '.'
+          ready?
+        end
+        info "\n(server ready)"
         if config[:floating_ip_pool]
           attach_ip_from_pool(server, config[:floating_ip_pool])
         elsif config[:floating_ip]
@@ -69,17 +73,15 @@ module Kitchen
         end
         state[:hostname] = get_ip(server)
         state[:ssh_key] = config[:private_key_path]
-        wait_for_sshd(state[:hostname], config[:username],
-          { :port => config[:port] }) ; info '(ssh ready)'
+        wait_for_sshd(state[:hostname], config[:username], port: config[:port])
+        info '(ssh ready)'
         if config[:key_name]
           info "Using OpenStack keypair <#{config[:key_name]}>"
         end
         info "Using public SSH key <#{config[:public_key_path]}>"
         info "Using private SSH key <#{config[:private_key_path]}>"
-        add_ohai_hint(state, config, server)
-        unless config[:key_name]
-          do_ssh_setup(state, config, server)
-        end
+        add_ohai_hint(state)
+        do_ssh_setup(state, config, server) unless config[:key_name]
       rescue Fog::Errors::Error, Excon::Errors::Error => ex
         raise ActionFailed, ex.message
       end
@@ -87,7 +89,7 @@ module Kitchen
       def destroy(state)
         return if state[:server_id].nil?
 
-        config[:disable_ssl_validation] and disable_ssl_validation
+        config[:disable_ssl_validation] && disable_ssl_validation
         server = compute.servers.get(state[:server_id])
         server.destroy unless server.nil?
         info "OpenStack instance <#{state[:server_id]}> destroyed."
@@ -99,20 +101,21 @@ module Kitchen
 
       def openstack_server
         server_def = {
-          :provider           => 'OpenStack',
-          :openstack_username => config[:openstack_username],
-          :openstack_api_key  => config[:openstack_api_key],
-          :openstack_auth_url => config[:openstack_auth_url]
+          provider: 'OpenStack'
         }
-        optional = [
-          :openstack_tenant, :openstack_region, :openstack_service_name
-        ]
-        optional.each do |o|
-          config[o] and server_def[o] = config[o]
-        end
+        required_server_settings.each { |s| server_def[s] = config[s] }
+        optional_server_settings.each { |s| server_def[s] = config[s] }
         server_def
       end
 
+      def required_server_settings
+        [:openstack_username, :openstack_api_key, :openstack_auth_url]
+      end
+
+      def optional_server_settings
+        [:openstack_tenant, :openstack_region, :openstack_service_name]
+      end
+
       def network
         Fog::Network.new(openstack_server)
       end
@@ -148,22 +151,18 @@ module Kitchen
 
       def init_config
         {
-          :name       => config[:server_name],
-          :image_ref  => find_image(config[:image_ref]).id,
-          :flavor_ref => find_flavor(config[:flavor_ref]).id,
+          name: config[:server_name],
+          image_ref: find_image(config[:image_ref]).id,
+          flavor_ref: find_flavor(config[:flavor_ref]).id
         }
       end
 
       def optional_config(c)
         case c
         when :security_groups
-          if config[c].kind_of?(Array)
-            config[c]
-          end
+          config[c] if config[c].is_a?(Array)
         when :user_data
-          if File.exist?(config[c])
-            File.open(config[c]) { |f| f.read }
-          end
+          File.open(config[c]) { |f| f.read } if File.exist?(config[c])
         else
           config[c]
         end
@@ -171,61 +170,53 @@ module Kitchen
 
       def find_image(image_ref)
         image = find_matching(compute.images, image_ref)
-        raise ActionFailed, 'Image not found' if !image
+        fail(ActionFailed, 'Image not found') unless image
         debug "Selected image: #{image.id} #{image.name}"
         image
       end
 
       def find_flavor(flavor_ref)
         flavor = find_matching(compute.flavors, flavor_ref)
-        raise ActionFailed, 'Flavor not found' if !flavor
+        fail(ActionFailed, 'Flavor not found') unless flavor
         debug "Selected flavor: #{flavor.id} #{flavor.name}"
         flavor
       end
 
       def find_network(network_ref)
         net = find_matching(network.networks.all, network_ref)
-        raise ActionFailed, 'Network not found' if !net
+        fail(ActionFailed, 'Network not found') unless net
         debug "Selected net: #{net.id} #{net.name}"
         net
       end
 
+      # Generate what should be a unique server name up to 63 total chars
+      # Base name:    15
+      # Username:     15
+      # Hostname:     23
+      # Random string: 7
+      # Separators:    3
+      # ================
+      # Total:        63
       def generate_name(base)
-        # Generate what should be a unique server name up to 63 total chars
-        # Base name:    15
-        # Username:     15
-        # Hostname:     23
-        # Random string: 7
-        # Separators:    3
-        # ================
-        # Total:        63
         sep = '-'
         pieces = [
-          base,
-          Etc.getlogin,
-          Socket.gethostname,
+          base.gsub(/\W/, '')[0..14],
+          Etc.getlogin.gsub(/\W/, '')[0..14],
+          Socket.gethostname.gsub(/\W/, '')[0..22],
           Array.new(7) { rand(36).to_s(36) }.join
         ]
-        until pieces.join(sep).length <= 63 do
-          if pieces[2].length > 23
-            pieces[2] = pieces[2][0..-2]
-          elsif pieces[1].length > 15
-            pieces[1] = pieces[1][0..-2]
-          elsif pieces[0].length > 15
-            pieces[0] = pieces[0][0..-2]
-          end
-        end
-        pieces.join sep
+        puts "Name: #{pieces.join(sep)}"
+        pieces.join(sep)
       end
 
       def attach_ip_from_pool(server, pool)
         @@ip_pool_lock.synchronize do
           info "Attaching floating IP from <#{pool}> pool"
-          free_addrs = compute.addresses.collect do |i|
-            i.ip if i.fixed_ip.nil? and i.instance_id.nil? and i.pool == pool
+          free_addrs = compute.addresses.map do |i|
+            i.ip if i.fixed_ip.nil? && i.instance_id.nil? && i.pool == pool
           end.compact
           if free_addrs.empty?
-            raise ActionFailed, "No available IPs in pool <#{pool}>"
+            fail ActionFailed, "No available IPs in pool <#{pool}>"
           end
           config[:floating_ip] = free_addrs[0]
           attach_ip(server, free_addrs[0])
@@ -252,11 +243,11 @@ module Kitchen
         rescue Fog::Compute::OpenStack::NotFound
           # See Fog issue: https://github.com/fog/fog/issues/2160
           addrs = server.addresses
-          addrs['public'] and pub = addrs['public'].map { |i| i['addr'] }
-          addrs['private'] and priv = addrs['private'].map { |i| i['addr'] }
+          addrs['public'] && pub = addrs['public'].map { |i| i['addr'] }
+          addrs['private'] && priv = addrs['private'].map { |i| i['addr'] }
         end
         pub, priv = parse_ips(pub, priv)
-        pub.first || priv.first || raise(ActionFailed, 'Could not find an IP')
+        pub.first || priv.first || fail(ActionFailed, 'Could not find an IP')
       end
 
       def parse_ips(pub, priv)
@@ -266,27 +257,28 @@ module Kitchen
         else
           [pub, priv].each { |n| n.select! { |i| IPAddr.new(i).ipv4? } }
         end
-        return pub, priv
+        [pub, priv]
       end
 
-      def add_ohai_hint(state, config, server)
+      def add_ohai_hint(state)
         info 'Adding OpenStack hint for ohai'
         ssh = Fog::SSH.new(*build_ssh_args(state))
         ssh.run([
-          %{sudo mkdir -p #{Ohai::Config[:hints_path][0]}},
-          %{sudo touch #{Ohai::Config[:hints_path][0]}/openstack.json}
+          %(sudo mkdir -p #{Ohai::Config[:hints_path][0]}),
+          %(sudo touch #{Ohai::Config[:hints_path][0]}/openstack.json)
         ])
       end
 
       def do_ssh_setup(state, config, server)
         info "Setting up SSH access for key <#{config[:public_key_path]}>"
-        ssh = Fog::SSH.new(state[:hostname], config[:username],
-          { :password => server.password })
+        ssh = Fog::SSH.new(state[:hostname],
+                           config[:username],
+                           password: server.password)
         pub_key = open(config[:public_key_path]).read
         ssh.run([
-          %{mkdir .ssh},
-          %{echo "#{pub_key}" >> ~/.ssh/authorized_keys},
-          %{passwd -l #{config[:username]}}
+          %(mkdir .ssh),
+          %(echo "#{pub_key}" >> ~/.ssh/authorized_keys),
+          %(passwd -l #{config[:username]})
         ])
       end
 
@@ -297,25 +289,18 @@ module Kitchen
 
       def find_matching(collection, name)
         name = name.to_s
-        if name.start_with?('/')
-          regex = eval(name)
+        if name.start_with?('/') && name.end_with?('/')
+          regex = Regexp.new(name[1...-1])
           # check for regex name match
-          collection.each do |single|
-            return single if regex =~ single.name
-          end
+          collection.each { |single| return single if regex =~ single.name }
         else
           # check for exact id match
-          collection.each do |single|
-            return single if single.id == name
-          end
+          collection.each { |single| return single if single.id == name }
           # check for exact name match
-          collection.each do |single|
-            return single if single.name == name
-          end
+          collection.each { |single| return single if single.name == name }
         end
         nil
       end
-
     end
   end
 end

data/lib/kitchen/driver/openstack_version.rb

@@ -17,8 +17,10 @@
 # limitations under the License.
 
 module Kitchen
+  # Version string for OpenStack Kitchen driver
+  #
+  # @author Jonathan Hartman <j@p4nt5.com>
   module Driver
-    # Version string for OpenStack Kitchen driver
-    OPENSTACK_VERSION = '1.5.2'
+    OPENSTACK_VERSION = '1.5.3'
   end
 end

data/spec/kitchen/driver/openstack_spec.rb

@@ -34,7 +34,7 @@ describe Kitchen::Driver::Openstack do
 
   let(:instance) do
     double(
-      :name => 'potatoes', :logger => logger, :to_str => 'instance'
+      name: 'potatoes', logger: logger, to_str: 'instance'
     )
   end
 
@@ -45,9 +45,9 @@ describe Kitchen::Driver::Openstack do
   end
 
   before(:each) do
-    File.stub(:exists?).and_call_original
-    File.stub(:exists?).with(dsa).and_return(true)
-    File.stub(:exists?).with(rsa).and_return(true)
+    allow(File).to receive(:exist?).and_call_original
+    allow(File).to receive(:exist?).with(dsa).and_return(true)
+    allow(File).to receive(:exist?).with(rsa).and_return(true)
   end
 
   describe '#initialize'do
@@ -64,9 +64,8 @@ describe Kitchen::Driver::Openstack do
 
       context 'only a DSA SSH key available for the user' do
         before(:each) do
-          File.unstub(:exists?)
-          File.stub(:exists?).and_return(false)
-          File.stub(:exists?).with(dsa).and_return(true)
+          allow(File).to receive(:exist?).and_return(false)
+          allow(File).to receive(:exist?).with(dsa).and_return(true)
         end
 
         it 'uses the local user\'s DSA private key' do
@@ -80,9 +79,8 @@ describe Kitchen::Driver::Openstack do
 
       context 'only a RSA SSH key available for the user' do
         before(:each) do
-          File.unstub(:exists?)
-          File.stub(:exists?).and_return(false)
-          File.stub(:exists?).with(rsa).and_return(true)
+          allow(File).to receive(:exist?).and_return(false)
+          allow(File).to receive(:exist?).with(rsa).and_return(true)
         end
 
         it 'uses the local user\'s RSA private key' do
@@ -118,19 +116,19 @@ describe Kitchen::Driver::Openstack do
     context 'overridden options' do
       let(:config) do
         {
-          :image_ref => '22',
-          :flavor_ref => '33',
-          :public_key_path => '/tmp',
-          :username => 'admin',
-          :port => '2222',
-          :server_name => 'puppy',
-          :openstack_tenant => 'that_one',
-          :openstack_region => 'atlantis',
-          :openstack_service_name => 'the_service',
-          :private_key_path => '/path/to/id_rsa',
-          :floating_ip_pool => 'swimmers',
-          :floating_ip => '11111',
-          :network_ref => '0xCAFFE'
+          image_ref: '22',
+          flavor_ref: '33',
+          public_key_path: '/tmp',
+          username: 'admin',
+          port: '2222',
+          server_name: 'puppy',
+          openstack_tenant: 'that_one',
+          openstack_region: 'atlantis',
+          openstack_service_name: 'the_service',
+          private_key_path: '/path/to/id_rsa',
+          floating_ip_pool: 'swimmers',
+          floating_ip: '11111',
+          network_ref: '0xCAFFE'
         }
       end
 
@@ -145,31 +143,29 @@ describe Kitchen::Driver::Openstack do
 
   describe '#create' do
     let(:server) do
-      double(:id => 'test123', :wait_for => true,
-        :public_ip_addresses => %w{1.2.3.4})
+      double(id: 'test123', wait_for: true, public_ip_addresses: %w(1.2.3.4))
     end
     let(:driver) do
       d = Kitchen::Driver::Openstack.new(config)
       d.instance = instance
-      d.stub(:generate_name).with('potatoes').and_return('a_monkey!')
-      d.stub(:create_server).and_return(server)
-      d.stub(:wait_for_sshd).with(
-        '1.2.3.4',
-        'root',
-        { :port => '22' }).and_return(true)
-      d.stub(:get_ip).and_return('1.2.3.4')
-      d.stub(:add_ohai_hint).and_return(true)
-      d.stub(:do_ssh_setup).and_return(true)
+      allow(d).to receive(:generate_name).with('potatoes')
+        .and_return('a_monkey!')
+      allow(d).to receive(:create_server).and_return(server)
+      allow(d).to receive(:wait_for_sshd).with('1.2.3.4', 'root', port: '22')
+        .and_return(true)
+      allow(d).to receive(:get_ip).and_return('1.2.3.4')
+      allow(d).to receive(:add_ohai_hint).and_return(true)
+      allow(d).to receive(:do_ssh_setup).and_return(true)
       d
     end
 
     context 'required options provided' do
       let(:config) do
         {
-          :openstack_username => 'hello',
-          :openstack_api_key => 'world',
-          :openstack_auth_url => 'http:',
-          :openstack_tenant => 'www'
+          openstack_username: 'hello',
+          openstack_api_key: 'world',
+          openstack_auth_url: 'http:',
+          openstack_tenant: 'www'
         }
       end
 
@@ -189,16 +185,16 @@ describe Kitchen::Driver::Openstack do
       end
 
       it 'does not disable SSL validation' do
-        driver.should_not_receive(:disable_ssl_validation)
+        expect(driver).to_not receive(:disable_ssl_validation)
         driver.create(state)
       end
     end
 
     context 'SSL validation disabled' do
-      let(:config) { { :disable_ssl_validation => true } }
+      let(:config) { { disable_ssl_validation: true } }
 
       it 'disables SSL cert validation' do
-        driver.should_receive(:disable_ssl_validation)
+        expect(driver).to receive(:disable_ssl_validation)
         driver.create(state)
       end
     end
@@ -207,27 +203,27 @@ describe Kitchen::Driver::Openstack do
   describe '#destroy' do
     let(:server_id) { '12345' }
     let(:hostname) { 'example.com' }
-    let(:state) { { :server_id => server_id, :hostname => hostname } }
-    let(:server) { double(:nil? => false, :destroy => true) }
-    let(:servers) { double(:get => server) }
-    let(:compute) { double(:servers => servers) }
+    let(:state) { { server_id: server_id, hostname: hostname } }
+    let(:server) { double(nil?: false, destroy: true) }
+    let(:servers) { double(get: server) }
+    let(:compute) { double(servers: servers) }
 
     let(:driver) do
       d = Kitchen::Driver::Openstack.new(config)
       d.instance = instance
-      d.stub(:compute).and_return(compute)
+      allow(d).to receive(:compute).and_return(compute)
       d
     end
 
     context 'a live server that needs to be destroyed' do
       it 'destroys the server' do
-        state.should_receive(:delete).with(:server_id)
-        state.should_receive(:delete).with(:hostname)
+        expect(state).to receive(:delete).with(:server_id)
+        expect(state).to receive(:delete).with(:hostname)
         driver.destroy(state)
       end
 
       it 'does not disable SSL cert validation' do
-        driver.should_not_receive(:disable_ssl_validation)
+        expect(driver).to_not receive(:disable_ssl_validation)
         driver.destroy(state)
       end
     end
@@ -236,9 +232,9 @@ describe Kitchen::Driver::Openstack do
       let(:state) { Hash.new }
 
       it 'does nothing' do
-        driver.stub(:compute)
-        driver.should_not_receive(:compute)
-        state.should_not_receive(:delete)
+        allow(driver).to receive(:compute)
+        expect(driver).to_not receive(:compute)
+        expect(state).to_not receive(:delete)
         driver.destroy(state)
       end
     end
@@ -246,14 +242,14 @@ describe Kitchen::Driver::Openstack do
     context 'a server that was already destroyed' do
       let(:servers) do
         s = double('servers')
-        s.stub(:get).with('12345').and_return(nil)
+        allow(s).to receive(:get).with('12345').and_return(nil)
         s
       end
-      let(:compute) { double(:servers => servers) }
+      let(:compute) { double(servers: servers) }
       let(:driver) do
         d = Kitchen::Driver::Openstack.new(config)
         d.instance = instance
-        d.stub(:compute).and_return(compute)
+        allow(d).to receive(:compute).and_return(compute)
         d
       end
 
@@ -264,43 +260,79 @@ describe Kitchen::Driver::Openstack do
     end
 
     context 'SSL validation disabled' do
-      let(:config) { { :disable_ssl_validation => true } }
+      let(:config) { { disable_ssl_validation: true } }
 
       it 'disables SSL cert validation' do
-        driver.should_receive(:disable_ssl_validation)
+        expect(driver).to receive(:disable_ssl_validation)
         driver.destroy(state)
       end
     end
   end
 
+  describe '#openstack_server' do
+    let(:config) do
+      {
+        openstack_username: 'a',
+        openstack_api_key: 'b',
+        openstack_auth_url: 'http://',
+        openstack_tenant: 'me',
+        openstack_region: 'ORD',
+        openstack_service_name: 'stack'
+      }
+    end
+
+    it 'returns a hash of server settings' do
+      expected = config.merge(provider: 'OpenStack')
+      expect(driver.send(:openstack_server)).to eq(expected)
+    end
+  end
+
+  describe '#required_server_settings' do
+    it 'returns the required settings for an OpenStack server' do
+      expected = [
+        :openstack_username, :openstack_api_key, :openstack_auth_url
+      ]
+      expect(driver.send(:required_server_settings)).to eq(expected)
+    end
+  end
+
+  describe '#optional_server_settings' do
+    it 'returns the optional settings for an OpenStack server' do
+      expected = [
+        :openstack_tenant, :openstack_region, :openstack_service_name
+      ]
+      expect(driver.send(:optional_server_settings)).to eq(expected)
+    end
+  end
+
   describe '#compute' do
     let(:config) do
       {
-        :openstack_username => 'monkey',
-        :openstack_api_key => 'potato',
-        :openstack_auth_url => 'http:',
-        :openstack_tenant => 'link',
-        :openstack_region => 'ord',
-        :openstack_service_name => 'the_service'
+        openstack_username: 'monkey',
+        openstack_api_key: 'potato',
+        openstack_auth_url: 'http:',
+        openstack_tenant: 'link',
+        openstack_region: 'ord',
+        openstack_service_name: 'the_service'
       }
     end
 
     context 'all requirements provided' do
       it 'creates a new compute connection' do
-        Fog::Compute.stub(:new) { |arg| arg }
-        res = config.merge({ :provider => 'OpenStack' })
+        allow(Fog::Compute).to receive(:new) { |arg| arg }
+        res = config.merge(provider: 'OpenStack')
         expect(driver.send(:compute)).to eq(res)
       end
 
       it 'creates a new network connection' do
-        Fog::Network.stub(:new) { |arg| arg }
-        res = config.merge({ :provider => 'OpenStack' })
+        allow(Fog::Network).to receive(:new) { |arg| arg }
+        res = config.merge(provider: 'OpenStack')
         expect(driver.send(:network)).to eq(res)
       end
     end
 
     context 'only an API key provided' do
-      let(:config) { { :openstack_api_key => '1234' } }
+      let(:config) { { openstack_api_key: '1234' } }
 
       it 'raises an error' do
         expect { driver.send(:compute) }.to raise_error(ArgumentError)
@@ -308,7 +340,7 @@ describe Kitchen::Driver::Openstack do
     end
 
     context 'only a username provided' do
-      let(:config) { { :openstack_username => 'monkey' } }
+      let(:config) { { openstack_username: 'monkey' } }
 
       it 'raises an error' do
         expect { driver.send(:compute) }.to raise_error(ArgumentError)
@@ -319,51 +351,45 @@ describe Kitchen::Driver::Openstack do
   describe '#create_server' do
     let(:config) do
       {
-        :server_name => 'hello',
-        :image_ref => '111',
-        :flavor_ref => '1',
-        :public_key_path => 'tarpals'
+        server_name: 'hello',
+        image_ref: '111',
+        flavor_ref: '1',
+        public_key_path: 'tarpals'
       }
     end
     let(:servers) do
       s = double('servers')
-      s.stub(:create) { |arg| arg }
+      allow(s).to receive(:create) { |arg| arg }
       s
     end
-    let(:vlan1_net) { double(:id => '1', :name => 'vlan1') }
-    let(:vlan2_net) { double(:id => '2', :name => 'vlan2') }
-    let(:ubuntu_image) { double(:id => '111', :name => 'ubuntu') }
-    let(:fedora_image) { double(:id => '222', :name => 'fedora') }
-    let(:tiny_flavor) { double(:id => '1', :name => 'tiny') }
-    let(:small_flavor) { double(:id => '2', :name => 'small') }
+    let(:vlan1_net) { double(id: '1', name: 'vlan1') }
+    let(:vlan2_net) { double(id: '2', name: 'vlan2') }
+    let(:ubuntu_image) { double(id: '111', name: 'ubuntu') }
+    let(:fedora_image) { double(id: '222', name: 'fedora') }
+    let(:tiny_flavor) { double(id: '1', name: 'tiny') }
+    let(:small_flavor) { double(id: '2', name: 'small') }
     let(:compute) do
       double(
-        :servers       => servers,
-        :images        => [ubuntu_image, fedora_image],
-        :flavors       => [tiny_flavor, small_flavor],
+        servers: servers,
+        images: [ubuntu_image, fedora_image],
+        flavors: [tiny_flavor, small_flavor]
       )
     end
     let(:network) do
-      double(
-        :networks => double(
-          :all => [vlan1_net, vlan2_net]
-        )
-      )
+      double(networks: double(all: [vlan1_net, vlan2_net]))
     end
     let(:driver) do
       d = Kitchen::Driver::Openstack.new(config)
       d.instance = instance
-      d.stub(:compute).and_return(compute)
-      d.stub(:network).and_return(network)
+      allow(d).to receive(:compute).and_return(compute)
+      allow(d).to receive(:network).and_return(network)
       d
     end
 
     context 'a default config' do
       before(:each) do
-        @expected = config.merge(:name => config[:server_name])
-        @expected.delete_if do |k, v|
-          k == :server_name
-        end
+        @expected = config.merge(name: config[:server_name])
+        @expected.delete_if { |k, _| k == :server_name }
       end
 
       it 'creates the server using a compute connection' do
@@ -374,17 +400,15 @@ describe Kitchen::Driver::Openstack do
     context 'a provided public key path' do
       let(:config) do
         {
-          :server_name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'tarpals'
+          server_name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'tarpals'
         }
       end
       before(:each) do
-        @expected = config.merge(:name => config[:server_name])
-        @expected.delete_if do |k, v|
-          k == :server_name
-        end
+        @expected = config.merge(name: config[:server_name])
+        @expected.delete_if { |k, _| k == :server_name }
       end
 
       it 'passes that public key path to Fog' do
@@ -395,19 +419,17 @@ describe Kitchen::Driver::Openstack do
     context 'a provided key name' do
       let(:config) do
         {
-          :server_name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'montgomery',
-          :key_name => 'tarpals'
+          server_name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'montgomery',
+          key_name: 'tarpals'
         }
       end
 
       before(:each) do
-        @expected = config.merge(:name => config[:server_name])
-        @expected.delete_if do |k, v|
-          k == :server_name
-        end
+        @expected = config.merge(name: config[:server_name])
+        @expected.delete_if { |k, _| k == :server_name }
       end
 
       it 'passes that key name to Fog' do
@@ -418,20 +440,18 @@ describe Kitchen::Driver::Openstack do
     context 'a provided security group' do
       let(:config) do
         {
-          :server_name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'montgomery',
-          :key_name => 'tarpals',
-          :security_groups => ['ping-and-ssh']
+          server_name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'montgomery',
+          key_name: 'tarpals',
+          security_groups: ['ping-and-ssh']
         }
       end
 
       before(:each) do
-        @expected = config.merge(:name => config[:server_name])
-        @expected.delete_if do |k, v|
-          k == :server_name
-        end
+        @expected = config.merge(name: config[:server_name])
+        @expected.delete_if { |k, _| k == :server_name }
       end
 
       it 'passes that security group to Fog' do
@@ -442,17 +462,18 @@ describe Kitchen::Driver::Openstack do
     context 'image/flavor specifies id' do
       let(:config) do
         {
-          :server_name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'tarpals'
+          server_name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'tarpals'
         }
       end
 
       it 'exact id match' do
-        servers.should_receive(:create).with(:name => 'hello',
-          :image_ref => '111', :flavor_ref => '1',
-          :public_key_path => 'tarpals')
+        expect(servers).to receive(:create).with(name: 'hello',
+                                                 image_ref: '111',
+                                                 flavor_ref: '1',
+                                                 public_key_path: 'tarpals')
         driver.send(:create_server)
       end
     end
@@ -460,17 +481,18 @@ describe Kitchen::Driver::Openstack do
     context 'image/flavor specifies name' do
       let(:config) do
         {
-          :server_name => 'hello',
-          :image_ref => 'fedora',
-          :flavor_ref => 'small',
-          :public_key_path => 'tarpals'
+          server_name: 'hello',
+          image_ref: 'fedora',
+          flavor_ref: 'small',
+          public_key_path: 'tarpals'
         }
       end
 
       it 'exact name match' do
-        servers.should_receive(:create).with(:name => 'hello',
-          :image_ref => '222', :flavor_ref => '2',
-          :public_key_path => 'tarpals')
+        expect(servers).to receive(:create).with(name: 'hello',
+                                                 image_ref: '222',
+                                                 flavor_ref: '2',
+                                                 public_key_path: 'tarpals')
         driver.send(:create_server)
       end
     end
@@ -478,18 +500,19 @@ describe Kitchen::Driver::Openstack do
     context 'image/flavor specifies regex' do
       let(:config) do
         {
-          :server_name => 'hello',
+          server_name: 'hello',
           # pass regex as string as yml returns string values
-          :image_ref => '/edo/',
-          :flavor_ref => '/in/',
-          :public_key_path => 'tarpals'
+          image_ref: '/edo/',
+          flavor_ref: '/in/',
+          public_key_path: 'tarpals'
         }
       end
 
       it 'regex name match' do
-        servers.should_receive(:create).with(:name => 'hello',
-          :image_ref => '222', :flavor_ref => '1',
-          :public_key_path => 'tarpals')
+        expect(servers).to receive(:create).with(name: 'hello',
+                                                 image_ref: '222',
+                                                 flavor_ref: '1',
+                                                 public_key_path: 'tarpals')
         driver.send(:create_server)
       end
     end
@@ -497,11 +520,11 @@ describe Kitchen::Driver::Openstack do
     context 'network specifies id' do
       let(:config) do
         {
-          :server_name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'tarpals',
-          :network_ref => '1'
+          server_name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'tarpals',
+          network_ref: '1'
         }
       end
 
@@ -509,12 +532,12 @@ describe Kitchen::Driver::Openstack do
         networks = [
           { 'net_id' => '1' }
         ]
-        servers.should_receive(:create).with(
-          :name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'tarpals',
-          :nics => networks
+        expect(servers).to receive(:create).with(
+          name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'tarpals',
+          nics: networks
         )
         driver.send(:create_server)
       end
@@ -523,11 +546,11 @@ describe Kitchen::Driver::Openstack do
     context 'network specifies name' do
       let(:config) do
         {
-          :server_name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'tarpals',
-          :network_ref => 'vlan1'
+          server_name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'tarpals',
+          network_ref: 'vlan1'
         }
       end
 
@@ -535,12 +558,12 @@ describe Kitchen::Driver::Openstack do
         networks = [
           { 'net_id' => '1' }
         ]
-        servers.should_receive(:create).with(
-          :name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'tarpals',
-          :nics => networks
+        expect(servers).to receive(:create).with(
+          name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'tarpals',
+          nics: networks
         )
         driver.send(:create_server)
       end
@@ -549,25 +572,25 @@ describe Kitchen::Driver::Openstack do
     context 'multiple networks specifies id' do
       let(:config) do
         {
-          :server_name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'tarpals',
-          :network_ref => %w(1 2)
+          server_name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'tarpals',
+          network_ref: %w(1 2)
         }
       end
 
       it 'exact id match' do
         networks = [
           { 'net_id' => '1' },
-          { 'net_id' => '2' },
+          { 'net_id' => '2' }
         ]
-        servers.should_receive(:create).with(
-          :name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'tarpals',
-          :nics => networks
+        expect(servers).to receive(:create).with(
+          name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'tarpals',
+          nics: networks
         )
         driver.send(:create_server)
       end
@@ -576,27 +599,27 @@ describe Kitchen::Driver::Openstack do
     context 'user_data specified' do
       let(:config) do
         {
-          :server_name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'tarpals',
-          :user_data => 'cloud-init.txt'
+          server_name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'tarpals',
+          user_data: 'cloud-init.txt'
         }
       end
       let(:data) { "#cloud-config\n" }
 
       before(:each) do
-        File.stub(:exist?).and_return(true)
-        File.stub(:open).and_return(data)
+        allow(File).to receive(:exist?).and_return(true)
+        allow(File).to receive(:open).and_return(data)
       end
 
-      it 'should pass file contents' do
-        servers.should_receive(:create).with(
-          :name => 'hello',
-          :image_ref => '111',
-          :flavor_ref => '1',
-          :public_key_path => 'tarpals',
-          :user_data => data)
+      it 'passes file contents' do
+        expect(servers).to receive(:create).with(
+          name: 'hello',
+          image_ref: '111',
+          flavor_ref: '1',
+          public_key_path: 'tarpals',
+          user_data: data)
         driver.send(:create_server)
       end
     end
@@ -604,8 +627,8 @@ describe Kitchen::Driver::Openstack do
 
   describe '#generate_name' do
     before(:each) do
-      Etc.stub(:getlogin).and_return('user')
-      Socket.stub(:gethostname).and_return('host')
+      allow(Etc).to receive(:getlogin).and_return('user')
+      allow(Socket).to receive(:gethostname).and_return('host')
     end
 
     it 'generates a name' do
@@ -615,41 +638,55 @@ describe Kitchen::Driver::Openstack do
 
     context 'local node with a long hostname' do
       before(:each) do
-        Socket.unstub(:gethostname)
-        Socket.stub(:gethostname).and_return('ab.c' * 20)
+        allow(Socket).to receive(:gethostname).and_return('ab.c' * 20)
       end
 
       it 'limits the generated name to 63 characters' do
-        expect(driver.send(:generate_name, 'long').length).to eq(63)
+        expect(driver.send(:generate_name, 'long').length).to be <= (63)
       end
     end
 
     context 'node with a long hostname, username, and base name' do
       before(:each) do
-        Socket.unstub(:gethostname)
-        Socket.stub(:gethostname).and_return('ab.c' * 20)
-
-        Etc.unstub(:getlogin)
-        Etc.stub(:getlogin).and_return('user' * 20)
+        allow(Socket).to receive(:gethostname).and_return('abc' * 20)
+        allow(Etc).to receive(:getlogin).and_return('user' * 20)
       end
 
       it 'limits the generated name to 63 characters' do
         expect(driver.send(:generate_name, 'long' * 20).length).to eq(63)
       end
     end
+
+    context 'a login and hostname with punctuation in them' do
+      let(:base) { 'a.base-name' }
+
+      before(:each) do
+        allow(Etc).to receive(:getlogin).and_return('some.u-se-r' * 20)
+        allow(Socket).to receive(:gethostname).and_return('a.host-name' * 20)
+      end
+
+      it 'strips out the dots to prevent bad server names' do
+        expect(driver.send(:generate_name, base)).to_not include('.')
+      end
+
+      it 'strips out all but the three hyphen separators' do
+        expect(driver.send(:generate_name, base).count('-')).to eq(3)
+      end
+    end
   end
 
   describe '#attach_ip_from_pool' do
     let(:server) { nil }
     let(:pool) { 'swimmers' }
     let(:ip) { '1.1.1.1' }
-    let(:address) { double(:ip => ip, :fixed_ip => nil, :instance_id => nil,
-      :pool => pool) }
-    let(:compute) { double(:addresses => [address]) }
+    let(:address) do
+      double(ip: ip, fixed_ip: nil, instance_id: nil, pool: pool)
+    end
+    let(:compute) { double(addresses: [address]) }
 
     before(:each) do
-      driver.stub(:attach_ip).with(server, ip).and_return('bing!')
-      driver.stub(:compute).and_return(compute)
+      allow(driver).to receive(:attach_ip).with(server, ip).and_return('bing!')
+      allow(driver).to receive(:compute).and_return(compute)
     end
 
     it 'determines an IP to attempt to attach' do
@@ -657,8 +694,10 @@ describe Kitchen::Driver::Openstack do
     end
 
     context 'no free addresses in the specified pool' do
-      let(:address) { double(:ip => ip, :fixed_ip => nil, :instance_id => nil,
-        :pool => 'some_other_pool') }
+      let(:address) do
+        double(ip: ip, fixed_ip: nil, instance_id: nil,
+               pool: 'some_other_pool')
+      end
 
       it 'raises an exception' do
         expect { driver.send(:attach_ip_from_pool, server, pool) }.to \
@@ -672,8 +711,8 @@ describe Kitchen::Driver::Openstack do
     let(:addresses) { {} }
     let(:server) do
       s = double('server')
-      s.should_receive(:associate_address).with(ip).and_return(true)
-      s.stub(:addresses).and_return(addresses)
+      expect(s).to receive(:associate_address).with(ip).and_return(true)
+      allow(s).to receive(:addresses).and_return(addresses)
       s
     end
 
@@ -691,19 +730,19 @@ describe Kitchen::Driver::Openstack do
     let(:driver) do
       d = Kitchen::Driver::Openstack.new(config)
       d.instance = instance
-      d.stub(:parse_ips).and_return(parsed_ips)
+      allow(d).to receive(:parse_ips).and_return(parsed_ips)
       d
     end
     let(:server) do
-      double(:addresses => addresses,
-        :public_ip_addresses => public_ip_addresses,
-        :private_ip_addresses => private_ip_addresses)
+      double(addresses: addresses,
+             public_ip_addresses: public_ip_addresses,
+             private_ip_addresses: private_ip_addresses)
     end
 
     context 'both public and private IPs' do
-      let(:public_ip_addresses) { %w{1::1 1.2.3.4} }
-      let(:private_ip_addresses) { %w{5.5.5.5} }
-      let(:parsed_ips) { [%w{1.2.3.4}, %w{5.5.5.5}] }
+      let(:public_ip_addresses) { %w(1::1 1.2.3.4) }
+      let(:private_ip_addresses) { %w(5.5.5.5) }
+      let(:parsed_ips) { [%w(1.2.3.4), %w(5.5.5.5)] }
 
       it 'returns a public IPv4 address' do
         expect(driver.send(:get_ip, server)).to eq('1.2.3.4')
@@ -711,8 +750,8 @@ describe Kitchen::Driver::Openstack do
     end
 
     context 'only public IPs' do
-      let(:public_ip_addresses) { %w{4.3.2.1 2::1} }
-      let(:parsed_ips) { [%w{4.3.2.1}, []] }
+      let(:public_ip_addresses) { %w(4.3.2.1 2::1) }
+      let(:parsed_ips) { [%w(4.3.2.1), []] }
 
       it 'returns a public IPv4 address' do
         expect(driver.send(:get_ip, server)).to eq('4.3.2.1')
@@ -720,8 +759,8 @@ describe Kitchen::Driver::Openstack do
     end
 
     context 'only private IPs' do
-      let(:private_ip_addresses) { %w{3::1 5.5.5.5} }
-      let(:parsed_ips) { [[], %w{5.5.5.5}] }
+      let(:private_ip_addresses) { %w(3::1 5.5.5.5) }
+      let(:parsed_ips) { [[], %w(5.5.5.5)] }
 
       it 'returns a private IPv4 address' do
         expect(driver.send(:get_ip, server)).to eq('5.5.5.5')
@@ -729,7 +768,7 @@ describe Kitchen::Driver::Openstack do
     end
 
     context 'IPs in user-defined network group' do
-      let(:config) { { :openstack_network_name => 'mynetwork' } }
+      let(:config) { { openstack_network_name: 'mynetwork' } }
       let(:addresses) do
         {
           'mynetwork' => [
@@ -747,10 +786,10 @@ describe Kitchen::Driver::Openstack do
     context 'an OpenStack deployment without the floating IP extension' do
       let(:server) do
         s = double('server')
-        s.stub(:addresses).and_return(addresses)
-        s.stub(:public_ip_addresses).and_raise(
+        allow(s).to receive(:addresses).and_return(addresses)
+        allow(s).to receive(:public_ip_addresses).and_raise(
           Fog::Compute::OpenStack::NotFound)
-        s.stub(:private_ip_addresses).and_raise(
+        allow(s).to receive(:private_ip_addresses).and_raise(
           Fog::Compute::OpenStack::NotFound)
         s
       end
@@ -762,7 +801,7 @@ describe Kitchen::Driver::Openstack do
             'private' => [{ 'addr' => '8.8.8.8' }, { 'addr' => '9.9.9.9' }]
           }
         end
-        let(:parsed_ips) { [%w{6.6.6.6 7.7.7.7}, %w{8.8.8.8 9.9.9.9}] }
+        let(:parsed_ips) { [%w(6.6.6.6 7.7.7.7), %w(8.8.8.8 9.9.9.9)] }
 
         it 'selects the first public IP' do
           expect(driver.send(:get_ip, server)).to eq('6.6.6.6')
@@ -773,7 +812,7 @@ describe Kitchen::Driver::Openstack do
         let(:addresses) do
           { 'public' => [{ 'addr' => '6.6.6.6' }, { 'addr' => '7.7.7.7' }] }
         end
-        let(:parsed_ips) { [%w{6.6.6.6 7.7.7.7}, []] }
+        let(:parsed_ips) { [%w(6.6.6.6 7.7.7.7), []] }
 
         it 'selects the first public IP' do
           expect(driver.send(:get_ip, server)).to eq('6.6.6.6')
@@ -784,7 +823,7 @@ describe Kitchen::Driver::Openstack do
         let(:addresses) do
           { 'private' => [{ 'addr' => '8.8.8.8' }, { 'addr' => '9.9.9.9' }] }
         end
-        let(:parsed_ips) { [[], %w{8.8.8.8 9.9.9.9}] }
+        let(:parsed_ips) { [[], %w(8.8.8.8 9.9.9.9)] }
 
         it 'selects the first private IP' do
           expect(driver.send(:get_ip, server)).to eq('8.8.8.8')
@@ -800,10 +839,10 @@ describe Kitchen::Driver::Openstack do
   end
 
   describe '#parse_ips' do
-    let(:pub_v4) { %w{1.1.1.1 2.2.2.2} }
-    let(:pub_v6) { %w{1::1 2::2} }
-    let(:priv_v4) { %w{3.3.3.3 4.4.4.4} }
-    let(:priv_v6) { %w{3::3 4::4} }
+    let(:pub_v4) { %w(1.1.1.1 2.2.2.2) }
+    let(:pub_v6) { %w(1::1 2::2) }
+    let(:priv_v4) { %w(3.3.3.3 4.4.4.4) }
+    let(:priv_v6) { %w(3::3 4::4) }
     let(:pub) { pub_v4 + pub_v6 }
     let(:priv) { priv_v4 + priv_v6 }
 
@@ -815,7 +854,7 @@ describe Kitchen::Driver::Openstack do
       end
 
       context 'IPv6' do
-        let(:config) { { :use_ipv6 => true } }
+        let(:config) { { use_ipv6: true } }
 
         it 'returns only the v6 IPs' do
           expect(driver.send(:parse_ips, pub, priv)).to eq([pub_v6, priv_v6])
@@ -833,7 +872,7 @@ describe Kitchen::Driver::Openstack do
       end
 
       context 'IPv6' do
-        let(:config) { { :use_ipv6 => true } }
+        let(:config) { { use_ipv6: true } }
 
         it 'returns only the v6 IPs' do
           expect(driver.send(:parse_ips, pub, priv)).to eq([pub_v6, []])
@@ -851,7 +890,7 @@ describe Kitchen::Driver::Openstack do
       end
 
       context 'IPv6' do
-        let(:config) { { :use_ipv6 => true } }
+        let(:config) { { use_ipv6: true } }
 
         it 'returns only the v6 IPs' do
           expect(driver.send(:parse_ips, pub, priv)).to eq([[], priv_v6])
@@ -870,7 +909,7 @@ describe Kitchen::Driver::Openstack do
       end
 
       context 'IPv6' do
-        let(:config) { { :use_ipv6 => true } }
+        let(:config) { { use_ipv6: true } }
 
         it 'returns empty lists' do
           expect(driver.send(:parse_ips, nil, nil)).to eq([[], []])
@@ -880,21 +919,21 @@ describe Kitchen::Driver::Openstack do
   end
 
   describe '#do_ssh_setup' do
-    let(:config) { { :public_key_path => '/pub_key' } }
-    let(:server) { double(:password => 'aloha') }
-    let(:state) { { :hostname => 'host' } }
-    let(:read) { double(:read => 'a_key') }
+    let(:config) { { public_key_path: '/pub_key' } }
+    let(:server) { double(password: 'aloha') }
+    let(:state) { { hostname: 'host' } }
+    let(:read) { double(read: 'a_key') }
     let(:ssh) do
       s = double('ssh')
-      s.stub(:run) { |args| args }
+      allow(s).to receive(:run) { |args| args }
       s
     end
 
     it 'opens an SSH session to the server' do
-      Fog::SSH.stub(:new).with('host', 'root',
-        { :password => 'aloha' }).and_return(ssh)
-      driver.stub(:open).with('/pub_key').and_return(read)
-      read.stub(:read).and_return('a_key')
+      allow(Fog::SSH).to receive(:new).with('host', 'root', password: 'aloha')
+        .and_return(ssh)
+      allow(driver).to receive(:open).with('/pub_key').and_return(read)
+      allow(read).to receive(:read).and_return('a_key')
       res = driver.send(:do_ssh_setup, state, config, server)
       expected = [
         'mkdir .ssh',
@@ -906,18 +945,16 @@ describe Kitchen::Driver::Openstack do
   end
 
   describe '#add_ohai_hint' do
-    let(:config) { { :public_key_path => '/pub_key' } }
-    let(:server) { double(:password => 'aloha') }
-    let(:state) { { :hostname => 'host' } }
+    let(:state) { { hostname: 'host' } }
     let(:ssh) do
       s = double('ssh')
-      s.stub(:run) { |args| args }
+      allow(s).to receive(:run) { |args| args }
       s
     end
     it 'opens an SSH session to the server' do
-      Fog::SSH.stub(:new).with('host', 'root',
-        anything()).and_return(ssh)
-      res = driver.send(:add_ohai_hint, state, config, server)
+      allow(Fog::SSH).to receive(:new).with('host', 'root', anything)
+        .and_return(ssh)
+      res = driver.send(:add_ohai_hint, state)
       expected = [
         "sudo mkdir -p #{Ohai::Config[:hints_path][0]}",
         "sudo touch #{Ohai::Config[:hints_path][0]}/openstack.json"