beaker-vagrant 0.7.0 → 1.0.0

data/spec/beaker/hypervisor/vagrant_spec.rb

@@ -3,414 +3,412 @@ require 'spec_helper'
 
 module Beaker
   describe Vagrant do
-
-    let( :options ) {
+    let(:options) do
       make_opts.merge({
-        'logger' => double().as_null_object,
-        :hosts_file => 'sample.cfg',
-        :forward_ssh_agent => true,
-      })
-    }
+                        'logger' => double.as_null_object,
+                        :hosts_file => 'sample.cfg',
+                        :forward_ssh_agent => true,
+                      })
+    end
 
-    let( :vagrant ) { Beaker::Vagrant.new( @hosts, options ) }
+    let(:vagrant) { Beaker::Vagrant.new(@hosts, options) }
 
     before :each do
       @hosts = make_hosts({
-        :mount_folders => {
-          :test_temp => {:from => './', :to => '/temp'},
-          :test_tmp => {:from => '../', :to => '/tmp'}
-        },
-        :forwarded_ports => {
-          :http => {:from => 10080, :to => 80},
-          :ssl  => {:from => 4443,  :to => 443},
-          :tomcat => {:from => 8080, :to => 8080}
-        },
-        :platform => Beaker::Platform.new('centos-8-x86_64')
-      })
+                            mount_folders: {
+                              test_temp: { from: './', to: '/temp' },
+                              test_tmp: { from: '../', to: '/tmp' }
+                            },
+                            forwarded_ports: {
+                              http: { from: 10_080, to: 80 },
+                              ssl: { from: 4443, to: 443 },
+                              tomcat: { from: 8080, to: 8080 }
+                            },
+                            platform: Beaker::Platform.new('centos-8-x86_64')
+                          })
     end
 
-    it "stores the vagrant file in $WORKINGDIR/.vagrant/beaker_vagrant_files/beaker_sample.cfg" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
-
-      expect( path ).to be === File.join(Dir.pwd, '.vagrant', 'beaker_vagrant_files', 'beaker_sample.cfg')
+    it 'stores the vagrant file in $WORKINGDIR/.vagrant/beaker_vagrant_files/beaker_sample.cfg' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
+      expect(path).to be === File.join(Dir.pwd, '.vagrant', 'beaker_vagrant_files', 'beaker_sample.cfg')
     end
 
-    it "can make a Vagrantfile for a set of hosts" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'can make a Vagrantfile for a set of hosts' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
-      vagrant.make_vfile( @hosts )
+      vagrant.make_vfile(@hosts)
 
-      vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
+      vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
       puts "file is #{path}\n"
-      expect( vagrantfile ).to be === <<-EOF
-Vagrant.configure("2") do |c|
-  c.ssh.insert_key = false
-  c.vm.define 'vm1' do |v|
-    v.vm.hostname = 'vm1'
-    v.vm.box = 'vm2vm1_of_my_box'
-    v.vm.box_url = 'http://address.for.my.box.vm1'
-    v.vm.box_check_update = 'true'
-    v.vm.network :private_network, ip: "ip.address.for.vm1", :netmask => "255.255.0.0"
-    v.vm.synced_folder './', '/temp', create: true
-    v.vm.synced_folder '../', '/tmp', create: true
-    v.vm.network :forwarded_port, guest: 80, host: 10080
-    v.vm.network :forwarded_port, guest: 443, host: 4443
-    v.vm.network :forwarded_port, guest: 8080, host: 8080
-    v.vm.provider :virtualbox do |vb|
-      vb.customize ['modifyvm', :id, '--memory', '1024', '--cpus', '1', '--audio', 'none']
-    end
-  end
-  c.vm.define 'vm2' do |v|
-    v.vm.hostname = 'vm2'
-    v.vm.box = 'vm2vm2_of_my_box'
-    v.vm.box_url = 'http://address.for.my.box.vm2'
-    v.vm.box_check_update = 'true'
-    v.vm.network :private_network, ip: "ip.address.for.vm2", :netmask => "255.255.0.0"
-    v.vm.synced_folder './', '/temp', create: true
-    v.vm.synced_folder '../', '/tmp', create: true
-    v.vm.network :forwarded_port, guest: 80, host: 10080
-    v.vm.network :forwarded_port, guest: 443, host: 4443
-    v.vm.network :forwarded_port, guest: 8080, host: 8080
-    v.vm.provider :virtualbox do |vb|
-      vb.customize ['modifyvm', :id, '--memory', '1024', '--cpus', '1', '--audio', 'none']
-    end
-  end
-  c.vm.define 'vm3' do |v|
-    v.vm.hostname = 'vm3'
-    v.vm.box = 'vm2vm3_of_my_box'
-    v.vm.box_url = 'http://address.for.my.box.vm3'
-    v.vm.box_check_update = 'true'
-    v.vm.network :private_network, ip: "ip.address.for.vm3", :netmask => "255.255.0.0"
-    v.vm.synced_folder './', '/temp', create: true
-    v.vm.synced_folder '../', '/tmp', create: true
-    v.vm.network :forwarded_port, guest: 80, host: 10080
-    v.vm.network :forwarded_port, guest: 443, host: 4443
-    v.vm.network :forwarded_port, guest: 8080, host: 8080
-    v.vm.provider :virtualbox do |vb|
-      vb.customize ['modifyvm', :id, '--memory', '1024', '--cpus', '1', '--audio', 'none']
-    end
-  end
-end
-EOF
+      expect(vagrantfile).to be === <<~EOF
+        Vagrant.configure("2") do |c|
+          c.ssh.insert_key = false
+          c.vm.define 'vm1' do |v|
+            v.vm.hostname = 'vm1'
+            v.vm.box = 'vm2vm1_of_my_box'
+            v.vm.box_url = 'http://address.for.my.box.vm1'
+            v.vm.box_check_update = 'true'
+            v.vm.network :private_network, ip: "ip.address.for.vm1", :netmask => "255.255.0.0"
+            v.vm.synced_folder './', '/temp', create: true
+            v.vm.synced_folder '../', '/tmp', create: true
+            v.vm.network :forwarded_port, guest: 80, host: 10080
+            v.vm.network :forwarded_port, guest: 443, host: 4443
+            v.vm.network :forwarded_port, guest: 8080, host: 8080
+            v.vm.provider :virtualbox do |vb|
+              vb.customize ['modifyvm', :id, '--memory', '1024', '--cpus', '1', '--audio', 'none']
+            end
+          end
+          c.vm.define 'vm2' do |v|
+            v.vm.hostname = 'vm2'
+            v.vm.box = 'vm2vm2_of_my_box'
+            v.vm.box_url = 'http://address.for.my.box.vm2'
+            v.vm.box_check_update = 'true'
+            v.vm.network :private_network, ip: "ip.address.for.vm2", :netmask => "255.255.0.0"
+            v.vm.synced_folder './', '/temp', create: true
+            v.vm.synced_folder '../', '/tmp', create: true
+            v.vm.network :forwarded_port, guest: 80, host: 10080
+            v.vm.network :forwarded_port, guest: 443, host: 4443
+            v.vm.network :forwarded_port, guest: 8080, host: 8080
+            v.vm.provider :virtualbox do |vb|
+              vb.customize ['modifyvm', :id, '--memory', '1024', '--cpus', '1', '--audio', 'none']
+            end
+          end
+          c.vm.define 'vm3' do |v|
+            v.vm.hostname = 'vm3'
+            v.vm.box = 'vm2vm3_of_my_box'
+            v.vm.box_url = 'http://address.for.my.box.vm3'
+            v.vm.box_check_update = 'true'
+            v.vm.network :private_network, ip: "ip.address.for.vm3", :netmask => "255.255.0.0"
+            v.vm.synced_folder './', '/temp', create: true
+            v.vm.synced_folder '../', '/tmp', create: true
+            v.vm.network :forwarded_port, guest: 80, host: 10080
+            v.vm.network :forwarded_port, guest: 443, host: 4443
+            v.vm.network :forwarded_port, guest: 8080, host: 8080
+            v.vm.provider :virtualbox do |vb|
+              vb.customize ['modifyvm', :id, '--memory', '1024', '--cpus', '1', '--audio', 'none']
+            end
+          end
+        end
+      EOF
     end
 
-    it "can make a Vagrantfile with ssh agent forwarding enabled" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'can make a Vagrantfile with ssh agent forwarding enabled' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
-      hosts = make_hosts({},1)
-      vagrant.make_vfile( hosts, options )
+      hosts = make_hosts({}, 1)
+      vagrant.make_vfile(hosts, options)
 
-      vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-      expect( vagrantfile ).to match(/(ssh.forward_agent = true)/)
+      vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
+      expect(vagrantfile).to match(/(ssh.forward_agent = true)/)
     end
 
-    it "can replace underscores in host.name with hypens" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
-
-      host = make_host( 'name-with_underscore', {} )
-      vagrant.make_vfile( [host,], options )
+    it 'can replace underscores in host.name with hypens' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
-      vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-      expect( vagrantfile ).to match(/v.vm.hostname = .*name-with-underscore/)
+      host = make_host('name-with_underscore', {})
+      vagrant.make_vfile([host,], options)
 
+      vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
+      expect(vagrantfile).to match(/v.vm.hostname = .*name-with-underscore/)
     end
 
-    it "can make a Vagrantfile with synced_folder disabled" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'can make a Vagrantfile with synced_folder disabled' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
-      hosts = make_hosts({:synced_folder => 'disabled'},1)
-      vagrant.make_vfile( hosts, options )
+      hosts = make_hosts({ synced_folder: 'disabled' }, 1)
+      vagrant.make_vfile(hosts, options)
 
-      vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-      expect( vagrantfile ).to match(/v.vm.synced_folder .* disabled: true/)
+      vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
+      expect(vagrantfile).to match(/v.vm.synced_folder .* disabled: true/)
     end
 
-    it "can make a Vagrantfile with network mac specified" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'can make a Vagrantfile with network mac specified' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
-      hosts = make_hosts({:network_mac => 'b6:33:ae:19:48:f9'},1)
-      vagrant.make_vfile( hosts, options )
+      hosts = make_hosts({ network_mac: 'b6:33:ae:19:48:f9' }, 1)
+      vagrant.make_vfile(hosts, options)
 
-      vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-      expect( vagrantfile ).to match(/v.vm.network :private_network, ip: "ip.address.for.vm1", :netmask => "255.255.0.0", :mac => "b6:33:ae:19:48:f9/)
+      vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
+      expect(vagrantfile).to match(/v.vm.network :private_network, ip: "ip.address.for.vm1", :netmask => "255.255.0.0", :mac => "b6:33:ae:19:48:f9/)
     end
 
-    it "can make a Vagrantfile with improper keys for synced folders" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'can make a Vagrantfile with improper keys for synced folders' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
-      hosts = make_hosts({:mount_folders => {
-        :test_invalid1 => {:host_path => '/invalid1', :container_path => '/invalid1'},
-        :test_invalid2 => {:from => '/invalid2', :container_path => '/invalid2'},
-        :test_invalid3 => {:host_path => '/invalid3', :to => '/invalid3'},
-        :test_valid => {:from => '/valid', :to => '/valid'}
-      }},1)
-      vagrant.make_vfile( hosts, options )
+      hosts = make_hosts({ mount_folders: {
+                           test_invalid1: { host_path: '/invalid1', container_path: '/invalid1' },
+                           test_invalid2: { from: '/invalid2', container_path: '/invalid2' },
+                           test_invalid3: { host_path: '/invalid3', to: '/invalid3' },
+                           test_valid: { from: '/valid', to: '/valid' }
+                         } }, 1)
+      vagrant.make_vfile(hosts, options)
 
-      vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
+      vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
 
-      expect( vagrantfile ).not_to match(/v.vm.synced_folder '', '', create: true/)
-      expect( vagrantfile ).not_to match(/v.vm.synced_folder '\/invalid2', '', create: true/)
-      expect( vagrantfile ).not_to match(/v.vm.synced_folder '', '\/invalid3', create: true/)
-      expect( vagrantfile ).to match(/v.vm.synced_folder '\/valid', '\/valid', create: true/)
+      expect(vagrantfile).not_to match(/v.vm.synced_folder '', '', create: true/)
+      expect(vagrantfile).not_to match(%r{v.vm.synced_folder '/invalid2', '', create: true})
+      expect(vagrantfile).not_to match(%r{v.vm.synced_folder '', '/invalid3', create: true})
+      expect(vagrantfile).to match(%r{v.vm.synced_folder '/valid', '/valid', create: true})
     end
 
-    it "can make a Vagrantfile with optional shell provisioner" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'can make a Vagrantfile with optional shell provisioner' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
       shell_path = '/path/to/shell/script'
       hosts = make_hosts({
-        :shell_provisioner => {
-          :path => shell_path
-        }
-      }, 1)
-      vagrant.make_vfile( hosts, options )
-
-      vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-      expect( vagrantfile ).to match(/v.vm.provision 'shell', :path => '#{shell_path}'/)
+                           shell_provisioner: {
+                             path: shell_path
+                           }
+                         }, 1)
+      vagrant.make_vfile(hosts, options)
+
+      vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
+      expect(vagrantfile).to match(/v.vm.provision 'shell', :path => '#{shell_path}'/)
     end
 
-    it "can make a Vagrantfile with optional shell provisioner with args" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'can make a Vagrantfile with optional shell provisioner with args' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
       shell_path = '/path/to/shell/script.sh'
       shell_args = 'arg1 arg2'
       hosts = make_hosts({
-        :shell_provisioner => {
-          :path => shell_path,
-          :args => shell_args
-        }
-      }, 1)
-      vagrant.make_vfile( hosts, options )
-
-      vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-      expect( vagrantfile ).to match(/v.vm.provision 'shell', :path => '#{shell_path}', :args => '#{shell_args}'/)
+                           shell_provisioner: {
+                             path: shell_path,
+                             args: shell_args
+                           }
+                         }, 1)
+      vagrant.make_vfile(hosts, options)
+
+      vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
+      expect(vagrantfile).to match(/v.vm.provision 'shell', :path => '#{shell_path}', :args => '#{shell_args}'/)
     end
 
-    it "raises an error if path is not set on shell_provisioner" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'raises an error if path is not set on shell_provisioner' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
-      hosts = make_hosts({:shell_provisioner => {}}, 1)
-      expect{ vagrant.make_vfile( hosts, options ) }.to raise_error RuntimeError, /No path defined for shell_provisioner or path empty/
+      hosts = make_hosts({ shell_provisioner: {} }, 1)
+      expect do
+        vagrant.make_vfile(hosts, options)
+      end.to raise_error RuntimeError, /No path defined for shell_provisioner or path empty/
     end
 
-    it "raises an error if path is EMPTY on shell_provisioner" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'raises an error if path is EMPTY on shell_provisioner' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
       empty_shell_path = ''
       hosts = make_hosts({
-        :shell_provisioner => {
-          :path => empty_shell_path
-        }
-      }, 1)
-      expect{ vagrant.make_vfile( hosts, options ) }.to raise_error RuntimeError, /No path defined for shell_provisioner or path empty/
+                           shell_provisioner: {
+                             path: empty_shell_path
+                           }
+                         }, 1)
+      expect do
+        vagrant.make_vfile(hosts, options)
+      end.to raise_error RuntimeError, /No path defined for shell_provisioner or path empty/
     end
 
-    context "when generating a windows config" do
+    context 'when generating a windows config' do
       before do
-        path = vagrant.instance_variable_get( :@vagrant_path )
+        path = vagrant.instance_variable_get(:@vagrant_path)
         @hosts[0][:platform] = 'windows'
 
-        vagrant.make_vfile( @hosts )
+        vagrant.make_vfile(@hosts)
 
-        @generated_file = File.read( File.expand_path( File.join( path, "Vagrantfile") ) )
+        @generated_file = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
       end
 
       it 'has the proper port forwarding for RDP' do
-        expect( @generated_file ).to match /v.vm.network :forwarded_port, guest: 3389, host: 3389, id: 'rdp', auto_correct: true/
+        expect(@generated_file).to match /v.vm.network :forwarded_port, guest: 3389, host: 3389, id: 'rdp', auto_correct: true/
       end
 
       it 'has the proper port forwarding for WinRM' do
-        expect( @generated_file ).to match /v.vm.network :forwarded_port, guest: 5985, host: 5985, id: 'winrm', auto_correct: true/
+        expect(@generated_file).to match /v.vm.network :forwarded_port, guest: 5985, host: 5985, id: 'winrm', auto_correct: true/
       end
 
       it 'configures the guest type to windows' do
-        expect( @generated_file ).to match /v.vm.guest = :windows/
+        expect(@generated_file).to match /v.vm.guest = :windows/
       end
 
       it 'configures the guest type to use winrm' do
-        expect( @generated_file ).to match /v.vm.communicator = 'winrm'/
+        expect(@generated_file).to match /v.vm.communicator = 'winrm'/
       end
 
       it 'sets a non-default memsize' do
-        expect( @generated_file ).to match /'--memory', '2048',/
+        expect(@generated_file).to match /'--memory', '2048',/
       end
     end
 
     context 'when generating a freebsd config' do
       before do
-        path = vagrant.instance_variable_get( :@vagrant_path )
+        path = vagrant.instance_variable_get(:@vagrant_path)
         @hosts[0][:platform] = 'freebsd'
 
-        vagrant.make_vfile( @hosts )
+        vagrant.make_vfile(@hosts)
 
-        @generated_file = File.read( File.expand_path( File.join( path, "Vagrantfile") ) )
+        @generated_file = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
       end
 
       it 'has the proper ssh shell' do
-        expect( @generated_file ).to match /v.ssh.shell = 'sh'\n/
+        expect(@generated_file).to match /v.ssh.shell = 'sh'\n/
       end
 
       it 'has the proper guest setting' do
-        expect( @generated_file ).to match /v.vm.guest = :freebsd\n/
+        expect(@generated_file).to match /v.vm.guest = :freebsd\n/
       end
     end
 
-    it "uses the memsize defined per vagrant host" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'uses the memsize defined per vagrant host' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
-      vagrant.make_vfile( @hosts, {'vagrant_memsize' => 'hello!'} )
+      vagrant.make_vfile(@hosts, { 'vagrant_memsize' => 'hello!' })
 
-      generated_file = File.read( File.expand_path( File.join( path, "Vagrantfile") ) )
+      generated_file = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
 
       match = generated_file.match(/vb.customize \['modifyvm', :id, '--memory', 'hello!', '--cpus', '1', '--audio', 'none'\]/)
 
-      expect( match ).to_not be nil
-
+      expect(match).to_not be nil
     end
 
-    it "uses the cpus defined per vagrant host" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
+    it 'uses the cpus defined per vagrant host' do
+      path = vagrant.instance_variable_get(:@vagrant_path)
 
-      vagrant.make_vfile( @hosts, {'vagrant_cpus' => 'goodbye!'} )
+      vagrant.make_vfile(@hosts, { 'vagrant_cpus' => 'goodbye!' })
 
-      generated_file = File.read( File.expand_path( File.join( path, "Vagrantfile") ) )
+      generated_file = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
 
       match = generated_file.match(/vb.customize \['modifyvm', :id, '--memory', '1024', '--cpus', 'goodbye!', '--audio', 'none'\]/)
 
-      expect( match ).to_not be nil
-
+      expect(match).to_not be nil
     end
 
-    context "port forwarding rules" do
-      it "supports all Vagrant parameters" do
-        path = vagrant.instance_variable_get( :@vagrant_path )
+    context 'port forwarding rules' do
+      it 'supports all Vagrant parameters' do
+        path = vagrant.instance_variable_get(:@vagrant_path)
 
         hosts = make_hosts(
           {
-            :forwarded_ports => {
-              :http => {
-                :from => 10080,
-                :from_ip => '127.0.0.1',
-                :to => 80,
-                :to_ip => '0.0.0.0',
-                :protocol => 'udp'
+            forwarded_ports: {
+              http: {
+                from: 10_080,
+                from_ip: '127.0.0.1',
+                to: 80,
+                to_ip: '0.0.0.0',
+                protocol: 'udp'
               }
             }
-          },1)
-        vagrant.make_vfile( hosts, options )
+          }, 1
+        )
+        vagrant.make_vfile(hosts, options)
 
-        vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-        expect( vagrantfile ).to match(/v.vm.network :forwarded_port, protocol: 'udp', guest_ip: '0.0.0.0', guest: 80, host_ip: '127.0.0.1', host: 10080/)
+        vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
+        expect(vagrantfile).to match(/v.vm.network :forwarded_port, protocol: 'udp', guest_ip: '0.0.0.0', guest: 80, host_ip: '127.0.0.1', host: 10080/)
       end
 
-      it "supports supports from_ip" do
-        path = vagrant.instance_variable_get( :@vagrant_path )
+      it 'supports supports from_ip' do
+        path = vagrant.instance_variable_get(:@vagrant_path)
 
         hosts = make_hosts(
-            {
-                :forwarded_ports => {
-                    :http => {
-                        :from => 10080,
-                        :from_ip => '127.0.0.1',
-                        :to => 80,
-                    }
-                }
-            },1)
-        vagrant.make_vfile( hosts, options )
+          {
+            forwarded_ports: {
+              http: {
+                from: 10_080,
+                from_ip: '127.0.0.1',
+                to: 80,
+              }
+            }
+          }, 1
+        )
+        vagrant.make_vfile(hosts, options)
 
-        vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-        expect( vagrantfile ).to match(/v.vm.network :forwarded_port, guest: 80, host_ip: '127.0.0.1', host: 10080/)
+        vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
+        expect(vagrantfile).to match(/v.vm.network :forwarded_port, guest: 80, host_ip: '127.0.0.1', host: 10080/)
       end
 
-      it "supports all to_ip" do
-        path = vagrant.instance_variable_get( :@vagrant_path )
+      it 'supports all to_ip' do
+        path = vagrant.instance_variable_get(:@vagrant_path)
 
         hosts = make_hosts(
-            {
-                :forwarded_ports => {
-                    :http => {
-                        :from => 10080,
-                        :to => 80,
-                        :to_ip => '0.0.0.0',
-                    }
-                }
-            },1)
-        vagrant.make_vfile( hosts, options )
+          {
+            forwarded_ports: {
+              http: {
+                from: 10_080,
+                to: 80,
+                to_ip: '0.0.0.0',
+              }
+            }
+          }, 1
+        )
+        vagrant.make_vfile(hosts, options)
 
-        vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-        expect( vagrantfile ).to match(/v.vm.network :forwarded_port, guest_ip: '0.0.0.0', guest: 80, host: 10080/)
+        vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
+        expect(vagrantfile).to match(/v.vm.network :forwarded_port, guest_ip: '0.0.0.0', guest: 80, host: 10080/)
       end
 
-      it "supports all protocol" do
-        path = vagrant.instance_variable_get( :@vagrant_path )
+      it 'supports all protocol' do
+        path = vagrant.instance_variable_get(:@vagrant_path)
 
         hosts = make_hosts(
-            {
-                :forwarded_ports => {
-                    :http => {
-                        :from => 10080,
-                        :to => 80,
-                        :protocol => 'udp'
-                    }
-                }
-            },1)
-        vagrant.make_vfile( hosts, options )
-
-        vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-        expect( vagrantfile ).to match(/v.vm.network :forwarded_port, protocol: 'udp', guest: 80, host: 10080/)
+          {
+            forwarded_ports: {
+              http: {
+                from: 10_080,
+                to: 80,
+                protocol: 'udp'
+              }
+            }
+          }, 1
+        )
+        vagrant.make_vfile(hosts, options)
 
+        vagrantfile = File.read(File.expand_path(File.join(path, 'Vagrantfile')))
+        expect(vagrantfile).to match(/v.vm.network :forwarded_port, protocol: 'udp', guest: 80, host: 10080/)
       end
     end
 
-    it "can generate a new /etc/hosts file referencing each host" do
-
+    it 'can generate a new /etc/hosts file referencing each host' do
       @hosts.each do |host|
-        expect( vagrant ).to receive( :get_domain_name ).with( host ).and_return( 'labs.lan' )
-        expect( vagrant ).to receive( :set_etc_hosts ).with( host, "127.0.0.1\tlocalhost localhost.localdomain\nip.address.for.vm1\tvm1.labs.lan vm1\nip.address.for.vm2\tvm2.labs.lan vm2\nip.address.for.vm3\tvm3.labs.lan vm3\n" ).once
+        expect(vagrant).to receive(:get_domain_name).with(host).and_return('labs.lan')
+        expect(vagrant).to receive(:set_etc_hosts).with(host,
+                                                        "127.0.0.1\tlocalhost localhost.localdomain\nip.address.for.vm1\tvm1.labs.lan vm1\nip.address.for.vm2\tvm2.labs.lan vm2\nip.address.for.vm3\tvm3.labs.lan vm3\n").once
       end
 
-      vagrant.hack_etc_hosts( @hosts, options )
-
+      vagrant.hack_etc_hosts(@hosts, options)
     end
 
     context "can copy vagrant's key to root .ssh on each host" do
-
-      it "can copy to root on unix" do
+      it 'can copy to root on unix' do
         host = @hosts[0]
         host[:platform] = 'unix'
 
-        expect( Command ).to receive( :new ).with("sudo su -c \"cp -r .ssh /root/.\"").once
-        expect( Command ).to receive( :new ).with("sudo fixfiles restore /root").once
-        expect( Command ).to receive( :new ).with("sudo selinuxenabled").once
-
-        vagrant.copy_ssh_to_root( host, options )
+        expect(Command).to receive(:new).with('sudo su -c "cp -r .ssh /root/."').once
+        expect(Command).to receive(:new).with('sudo fixfiles restore /root').once
+        expect(Command).to receive(:new).with('sudo selinuxenabled').once
 
+        vagrant.copy_ssh_to_root(host, options)
       end
 
-      it "can copy to Administrator on windows" do
+      it 'can copy to Administrator on windows' do
         host = @hosts[0]
         host[:platform] = 'windows'
-        expect( host ).to receive( :is_cygwin? ).and_return(true)
+        expect(host).to receive(:is_cygwin?).and_return(true)
 
-        expect( Command ).to_not receive( :new ).with("sudo fixfiles restore /root")
-        expect( Command ).to receive( :new ).with("cp -r .ssh /cygdrive/c/Users/Administrator/.").once
-        expect( Command ).to receive( :new ).with("chown -R Administrator /cygdrive/c/Users/Administrator/.ssh").once
+        expect(Command).to_not receive(:new).with('sudo fixfiles restore /root')
+        expect(Command).to receive(:new).with('cp -r .ssh /cygdrive/c/Users/Administrator/.').once
+        expect(Command).to receive(:new).with('chown -R Administrator /cygdrive/c/Users/Administrator/.ssh').once
 
         # This is checked on all platforms since Linux isn't called out specifically in the code
         # If this fails, nothing further is activated
         result = Beaker::Result.new(host, '')
         result.exit_code = 1
-        expect( Command ).to receive( :new ).with("sudo selinuxenabled")
-        allow( host ).to receive(:exec).and_return(result)
-
-        vagrant.copy_ssh_to_root( host, options )
+        expect(Command).to receive(:new).with('sudo selinuxenabled')
+        allow(host).to receive(:exec).and_return(result)
 
+        vagrant.copy_ssh_to_root(host, options)
       end
     end
 
-    describe "set_ssh_config" do
-      let( :out ) do
+    describe 'set_ssh_config' do
+      let(:out) do
         <<-CONFIG
         Host #{name}
           HostName 127.0.0.1
@@ -423,9 +421,9 @@ EOF
           IdentitiesOnly yes
         CONFIG
       end
-      let( :host ) { @hosts[0] }
-      let( :name ) { host.name }
-      let( :override_options ) { {} }
+      let(:host) { @hosts[0] }
+      let(:name) { host.name }
+      let(:override_options) { {} }
 
       before :each do
         # FakeFS is just broken with Tempfile
@@ -433,11 +431,12 @@ EOF
         Dir.mktmpdir do |dir|
           vagrant.instance_variable_get(:@options).merge!(override_options)
           vagrant.instance_variable_set(:@vagrant_path, dir)
-          state = double( 'state' )
-          allow( state ).to receive( :success? ).and_return( true )
-          allow( Open3 ).to receive( :capture3 ).with( {"RUBYLIB"=>"", "RUBYOPT"=>""}, 'vagrant', 'ssh-config', name ).and_return( [ out, "", state ])
+          state = double('state')
+          allow(state).to receive(:success?).and_return(true)
+          allow(Open3).to receive(:capture3).with({ 'RUBYLIB' => '', 'RUBYOPT' => '' }, 'vagrant', 'ssh-config',
+                                                  name).and_return([out, '', state])
 
-          vagrant.set_ssh_config( host, 'root' )
+          vagrant.set_ssh_config(host, 'root')
         end
       end
 
@@ -454,13 +453,13 @@ EOF
         expect(host['ssh'][:keys_only]).to be === false
       end
 
-      context "when :forward_ssh_agent is false" do
+      context 'when :forward_ssh_agent is false' do
         let(:override_options) do
-          {forward_ssh_agent: false}
+          { forward_ssh_agent: false }
         end
 
-        it "should keep IdentitiesOnly to yes" do
-          expect( host['ssh'][:keys_only]).to be === true
+        it 'should keep IdentitiesOnly to yes' do
+          expect(host['ssh'][:keys_only]).to be === true
         end
       end
     end
@@ -517,87 +516,80 @@ EOF
       end
     end
 
-    describe "provisioning and cleanup" do
-
+    describe 'provisioning and cleanup' do
       before :each do
-        expect( vagrant ).to receive( :vagrant_cmd ).with( "up" ).once
+        expect(vagrant).to receive(:vagrant_cmd).with('up').once
         @hosts.each do |host|
           host_prev_name = host['user']
-          expect( vagrant ).to receive( :set_ssh_config ).with( host, 'vagrant' ).once
-          expect( vagrant ).to receive( :copy_ssh_to_root ).with( host, options ).once
-          expect( vagrant ).to receive( :set_ssh_config ).with( host, host_prev_name ).once
+          expect(vagrant).to receive(:set_ssh_config).with(host, 'vagrant').once
+          expect(vagrant).to receive(:copy_ssh_to_root).with(host, options).once
+          expect(vagrant).to receive(:set_ssh_config).with(host, host_prev_name).once
         end
-        expect( vagrant ).to receive( :hack_etc_hosts ).with( @hosts, options ).once
+        expect(vagrant).to receive(:hack_etc_hosts).with(@hosts, options).once
       end
 
-      it "can provision a set of hosts" do
-        options = vagrant.instance_variable_get( :@options )
-        expect( vagrant ).to receive( :make_vfile ).with( @hosts, options ).once
-        expect( vagrant ).to receive( :vagrant_cmd ).with( "destroy --force" ).never
+      it 'can provision a set of hosts' do
+        options = vagrant.instance_variable_get(:@options)
+        expect(vagrant).to receive(:make_vfile).with(@hosts, options).once
+        expect(vagrant).to receive(:vagrant_cmd).with('destroy --force').never
         vagrant.provision
       end
 
-      it "destroys an existing set of hosts before provisioning" do
-        vagrant.make_vfile( @hosts )
-        expect( vagrant ).to receive( :vagrant_cmd ).with( "destroy --force" ).once
+      it 'destroys an existing set of hosts before provisioning' do
+        vagrant.make_vfile(@hosts)
+        expect(vagrant).to receive(:vagrant_cmd).with('destroy --force').once
         vagrant.provision
       end
 
-      it "notifies user of failed provision" do
+      it 'notifies user of failed provision' do
         vagrant.provision
-        expect( vagrant ).to receive( :vagrant_cmd ).with( "destroy --force" ).and_raise( RuntimeError )
-        expect( options['logger'] ).to receive( :debug ).with( /Vagrantfile/ )
-        expect{ vagrant.provision }.to raise_error( RuntimeError )
+        expect(vagrant).to receive(:vagrant_cmd).with('destroy --force').and_raise(RuntimeError)
+        expect(options['logger']).to receive(:debug).with(/Vagrantfile/)
+        expect { vagrant.provision }.to raise_error(RuntimeError)
       end
 
-      it "can cleanup" do
-        expect( vagrant ).to receive( :vagrant_cmd ).with( "destroy --force" ).once
-        expect( FileUtils ).to receive( :rm_rf ).once
+      it 'can cleanup' do
+        expect(vagrant).to receive(:vagrant_cmd).with('destroy --force').once
+        expect(FileUtils).to receive(:rm_rf).once
 
         vagrant.provision
         vagrant.cleanup
-
       end
-
     end
 
-    describe "provisioning and cleanup on windows" do
+    describe 'provisioning and cleanup on windows' do
       before :each do
-        expect( vagrant ).to receive( :vagrant_cmd ).with( "up" ).once
+        expect(vagrant).to receive(:vagrant_cmd).with('up').once
         @hosts.each do |host|
           host[:platform] = 'windows'
           host_prev_name = host['user']
-          expect( vagrant ).not_to receive( :set_ssh_config ).with( host, 'vagrant' )
-          expect( vagrant ).not_to receive( :copy_ssh_to_root ).with( host, options )
-          expect( vagrant ).to receive( :set_ssh_config ).with( host, host_prev_name ).once
+          expect(vagrant).not_to receive(:set_ssh_config).with(host, 'vagrant')
+          expect(vagrant).not_to receive(:copy_ssh_to_root).with(host, options)
+          expect(vagrant).to receive(:set_ssh_config).with(host, host_prev_name).once
         end
-        expect( vagrant ).to receive( :hack_etc_hosts ).with( @hosts, options ).once
+        expect(vagrant).to receive(:hack_etc_hosts).with(@hosts, options).once
       end
 
-      it "can provision a set of hosts" do
-        options = vagrant.instance_variable_get( :@options )
-        expect( vagrant ).to receive( :make_vfile ).with( @hosts, options ).once
-        expect( vagrant ).to receive( :vagrant_cmd ).with( "destroy --force" ).never
+      it 'can provision a set of hosts' do
+        options = vagrant.instance_variable_get(:@options)
+        expect(vagrant).to receive(:make_vfile).with(@hosts, options).once
+        expect(vagrant).to receive(:vagrant_cmd).with('destroy --force').never
         vagrant.provision
       end
 
-      it "destroys an existing set of hosts before provisioning" do
-        vagrant.make_vfile( @hosts )
-        expect( vagrant ).to receive( :vagrant_cmd ).with( "destroy --force" ).once
+      it 'destroys an existing set of hosts before provisioning' do
+        vagrant.make_vfile(@hosts)
+        expect(vagrant).to receive(:vagrant_cmd).with('destroy --force').once
         vagrant.provision
       end
 
-      it "can cleanup" do
-        expect( vagrant ).to receive( :vagrant_cmd ).with( "destroy --force" ).once
-        expect( FileUtils ).to receive( :rm_rf ).once
+      it 'can cleanup' do
+        expect(vagrant).to receive(:vagrant_cmd).with('destroy --force').once
+        expect(FileUtils).to receive(:rm_rf).once
 
         vagrant.provision
         vagrant.cleanup
-
       end
-
     end
-
   end
-
 end