beaker 3.20.0 → 3.21.0

data/spec/beaker/hypervisor/ec2_helper_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-require 'beaker/hypervisor/ec2_helper'
-
-describe Beaker::EC2Helper do
-  context ".amiports" do
-    let(:ec2) { Beaker::EC2Helper }
-
-    let(:master_host)  do
-      opts = { :snapshot => :pe, :roles => ['master'], :additional_ports => 9999 }
-      make_host('master', opts)
-    end
-
-    let(:database_host)  do
-      opts = { :snapshot => :pe, :roles => ['database'], :additional_ports => [1111, 5432] }
-      make_host('database', opts)
-    end
-
-    let(:dashboard_host)  do
-      opts = { :snapshot => :pe, :roles => ['dashboard'], :additional_ports => 2003 }
-      make_host('dashboard', opts)
-    end
-
-    let(:all_in_one_host)  do
-      opts = { :snapshot => :pe, :roles => ['master', 'database', 'dashboard']}
-      make_host('all_in_one', opts)
-    end
-
-    it "can set ports for database host" do
-      expect(ec2.amiports(database_host)).to be === [22, 61613, 8139, 5432, 8080, 8081, 1111]
-    end
-
-    it "can set ports for master host" do
-      expect(ec2.amiports(master_host)).to be === [22, 61613, 8139, 8140, 9999]
-    end
-
-    it "can set ports for dashboard host" do
-      expect(ec2.amiports(dashboard_host)).to be === [22, 61613, 8139, 443, 4433, 4435, 2003]
-    end
-
-    it "can set ports for combined master/database/dashboard host" do
-      expect(ec2.amiports(all_in_one_host)).to be === [22, 61613, 8139, 5432, 8080, 8081, 8140, 443, 4433, 4435]
-    end
-  end
-end

data/spec/beaker/hypervisor/fusion_spec.rb

@@ -1,41 +0,0 @@
-require 'spec_helper'
-
-module Beaker
-  describe Fusion do
-    let( :fusion ) { Beaker::Fusion.new( @hosts, make_opts ) }
-
-    before :each do
-     stub_const( "Fission::VM", true )
-      @hosts = make_hosts()
-      MockFission.presets( @hosts )
-      allow_any_instance_of( Fusion ).to receive( :require ).with( 'fission' ).and_return( true )
-      fusion.instance_variable_set( :@fission, MockFission ) 
-    end
-
-    it "can interoperate with the fission library to provision hosts"  do
-      fusion.provision
-    end
-
-    it "raises an error if unknown snapshot name is used" do
-      @hosts[0][:snapshot] = 'unknown'
-      expect{ fusion.provision }.to raise_error
-    end
-
-    it 'raises an error if snapshots is nil' do
-      MockFissionVM.set_snapshots(nil)
-      expect{ fusion.provision }.to raise_error(/No snapshots available/)
-    end
-
-    it 'raises an error if snapshots are empty' do
-      MockFissionVM.set_snapshots([])
-      expect{ fusion.provision }.to raise_error(/No snapshots available/)
-    end
-
-    it 'host fails init with nil snapshot' do
-      @hosts[0][:snapshot] = nil
-      expect{ Beaker::Fusion.new( @hosts, make_opts) }.to raise_error(/specify a snapshot/)
-    end
-
-  end
-
-end

data/spec/beaker/hypervisor/vagrant_custom_spec.rb

@@ -1,46 +0,0 @@
-require 'spec_helper'
-
-describe Beaker::VagrantCustom do
-  let( :options ) { make_opts.merge({ :hosts_file => 'sample.cfg', 'logger' => double().as_null_object }) }
-  let( :vagrant ) { Beaker::VagrantCustom.new( @hosts, options ) }
-
-  let(:test_dir) { 'tmp/tests' }
-  let(:custom_vagrant_file_path)  { File.expand_path(test_dir + '/CustomVagrantfile')   }
-
-  before :each do
-    @hosts = make_hosts()
-  end
-
-  it "uses the vagrant_custom provider for provisioning" do
-    @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
-    end
-    expect( vagrant ).to receive( :hack_etc_hosts ).with( @hosts, options ).once
-    FakeFS.activate!
-    expect( vagrant ).to receive( :vagrant_cmd ).with( "up" ).once
-    vagrant.provision
-  end
-
-  context 'takes vagrant configuration from existing file' do
-    it 'writes the vagrant file to the correct location' do
-      options.merge!({ :vagrantfile_path => custom_vagrant_file_path })
-
-      create_files([custom_vagrant_file_path])
-
-      vagrant_file_contents = <<-EOF
-FOO
-      EOF
-      File.open(custom_vagrant_file_path, 'w') { |file| file.write(vagrant_file_contents) }
-
-      vagrant_copy_location = "#{test_dir}/NewVagrantLocation"
-      vagrant.instance_variable_set(:@vagrant_file, vagrant_copy_location)
-      vagrant.make_vfile(@hosts, options)
-      vagrant_copy_file = File.open(vagrant_copy_location, 'r')
-      expect(vagrant_copy_file.read).to be === vagrant_file_contents
-    end
-
-  end
-end

data/spec/beaker/hypervisor/vagrant_fusion_spec.rb

@@ -1,32 +0,0 @@
-require 'spec_helper'
-
-describe Beaker::VagrantFusion do
-  let( :options ) { make_opts.merge({ :hosts_file => 'sample.cfg', 'logger' => double().as_null_object }) }
-  let( :vagrant ) { Beaker::VagrantFusion.new( @hosts, options ) }
-
-  before :each do
-    @hosts = make_hosts()
-  end
-
-  it "uses the vmware_fusion provider for provisioning" do
-    @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
-    end
-    expect( vagrant ).to receive( :hack_etc_hosts ).with( @hosts, options ).once
-    expect( vagrant ).to receive( :vagrant_cmd ).with( "up --provider vmware_fusion" ).once
-    vagrant.provision
-  end
-
-  it "can make a Vagranfile for a set of hosts" do
-    path = vagrant.instance_variable_get( :@vagrant_path )
-    allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-    vagrant.make_vfile( @hosts )
-
-    vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-    expect( vagrantfile ).to include( %Q{    v.vm.provider :vmware_fusion do |v|\n      v.vmx['memsize'] = '1024'\n    end})
-  end
-end

data/spec/beaker/hypervisor/vagrant_libvirt_spec.rb

@@ -1,61 +0,0 @@
-require 'spec_helper'
-
-describe Beaker::VagrantLibvirt do
-  let( :options ) { make_opts.merge({ :hosts_file => 'sample.cfg',
-                                      'logger' => double().as_null_object,
-                                      'libvirt' => { 'uri' => 'qemu+ssh://root@host/system'},
-                                      'vagrant_cpus' => 2,
-                                    }) }
-  let( :vagrant ) { Beaker::VagrantLibvirt.new( @hosts, options ) }
-
-  before :each do
-    @hosts = make_hosts()
-  end
-
-  it "uses the vagrant_libvirt provider for provisioning" do
-    @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
-    end
-    expect( vagrant ).to receive( :hack_etc_hosts ).with( @hosts, options ).once
-    FakeFS.activate!
-    expect( vagrant ).to receive( :vagrant_cmd ).with( "up --provider libvirt" ).once
-    vagrant.provision
-  end
-
-  context 'Correct vagrant configuration' do
-    before(:each) do
-      FakeFS.activate!
-      path = vagrant.instance_variable_get( :@vagrant_path )
-
-      vagrant.make_vfile( @hosts, options )
-      @vagrantfile = File.read( File.expand_path( File.join( path, "Vagrantfile")))
-    end
-
-    it "can make a Vagranfile for a set of hosts" do
-      expect( @vagrantfile ).to include( %Q{    v.vm.provider :libvirt do |node|})
-    end
-
-    it "can specify the memory as an integer" do
-      expect( @vagrantfile.split("\n").map(&:strip) )
-        .to include('node.memory = 1024')
-    end
-
-    it "can specify the number of cpus" do
-      expect( @vagrantfile.split("\n").map(&:strip) )
-        .to include("node.cpus = 2")
-    end
-
-    it "can specify any libvirt option" do
-      expect( @vagrantfile.split("\n").map(&:strip) )
-        .to include("node.uri = 'qemu+ssh://root@host/system'")
-    end
-
-    it "has a mac address in the proper format" do
-      expect( @vagrantfile.split("\n").map(&:strip) )
-        .to include(/:mac => "08:00:27:\h{2}:\h{2}:\h{2}"/)
-    end
-  end
-end

data/spec/beaker/hypervisor/vagrant_parallels_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe Beaker::VagrantParallels do
-  let( :options ) { make_opts.merge({ :hosts_file => 'sample.cfg', 'logger' => double().as_null_object }) }
-  let( :vagrant ) { Beaker::VagrantParallels.new( @hosts, options ) }
-
-  before :each do
-    @hosts = make_hosts()
-  end
-
-  it "uses the parallels provider for provisioning" do
-    @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
-    end
-    expect( vagrant ).to receive( :hack_etc_hosts ).with( @hosts, options ).once
-    expect( vagrant ).to receive( :vagrant_cmd ).with( "up --provider parallels" ).once
-    vagrant.provision
-  end
-
-  it "can make a Vagranfile for a set of hosts" do
-    path = vagrant.instance_variable_get( :@vagrant_path )
-    allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-    vagrant.make_vfile( @hosts )
-
-    vagrantfile = File.read( File.expand_path( File.join( path, 'Vagrantfile' )))
-    expect( vagrantfile ).to include( %Q{    v.vm.provider :parallels do |prl|\n      prl.optimize_power_consumption = false\n      prl.memory = '1024'\n    end})
-  end
-
-  it "can disable the auto-update functionality of the Parallels Guest Tools" do
-    options.merge!({ :prl_update_guest_tools => 'disable' })
-
-    vfile_section = vagrant.class.provider_vfile_section( @hosts.first, options )
-
-    match = vfile_section.match(/prl.update_guest_tools = false/)
-
-    expect( match ).to_not be nil
-
-  end
-
-end

data/spec/beaker/hypervisor/vagrant_spec.rb

@@ -1,479 +0,0 @@
-require 'spec_helper'
-
-module Beaker
-  describe Vagrant do
-
-    let( :options ) {
-      make_opts.merge({
-        'logger' => double().as_null_object,
-        :hosts_file => 'sample.cfg',
-        :forward_ssh_agent => true,
-      })
-    }
-
-    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}
-        }
-      })
-    end
-
-    it "stores the vagrant file in $WORKINGDIR/.vagrant/beaker_vagrant_files/sample.cfg" do
-      allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-      path = vagrant.instance_variable_get( :@vagrant_path )
-
-      expect( path ).to be === File.join(Dir.pwd, '.vagrant', 'beaker_vagrant_files', 'sample.cfg')
-
-    end
-
-    it "can make a Vagrantfile for a set of hosts" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
-      allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-      vagrant.make_vfile( @hosts )
-
-      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", :mac => "0123456789"
-    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']
-    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", :mac => "0123456789"
-    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']
-    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", :mac => "0123456789"
-    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']
-    end
-  end
-end
-EOF
-    end
-
-    it "can make a Vagrantfile with ssh agent forwarding enabled" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
-      allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-      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)/)
-    end
-
-    it "can make a Vagrantfile with synced_folder disabled" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
-      allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-      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/)
-    end
-
-    it "can make a Vagrantfile with network mac autogenerated" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
-
-      hosts = make_hosts({},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 => ".+/)
-    end
-
-    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 )
-
-      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 network mac disabled" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
-
-      hosts = make_hosts({:network_mac => 'false'},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"/)
-    end
-
-    context "when generating a windows config" do
-      before do
-        path = vagrant.instance_variable_get( :@vagrant_path )
-        allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-        @hosts[0][:platform] = 'windows'
-
-        vagrant.make_vfile( @hosts )
-
-        @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/
-      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/
-      end
-
-      it 'configures the guest type to windows' do
-        expect( @generated_file ).to match /v.vm.guest = :windows/
-      end
-
-      it 'sets a non-default memsize' do
-        expect( @generated_file ).to match /'--memory', '2048',/
-      end
-    end
-
-    it "uses the memsize defined per vagrant host" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
-      allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-      vagrant.make_vfile( @hosts, {'vagrant_memsize' => 'hello!'} )
-
-      generated_file = File.read( File.expand_path( File.join( path, "Vagrantfile") ) )
-
-      match = generated_file.match(/vb.customize \['modifyvm', :id, '--memory', 'hello!', '--cpus', '1'\]/)
-
-      expect( match ).to_not be nil
-
-    end
-
-    it "uses the cpus defined per vagrant host" do
-      path = vagrant.instance_variable_get( :@vagrant_path )
-      allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-      vagrant.make_vfile( @hosts, {'vagrant_cpus' => 'goodbye!'} )
-
-      generated_file = File.read( File.expand_path( File.join( path, "Vagrantfile") ) )
-
-      match = generated_file.match(/vb.customize \['modifyvm', :id, '--memory', '1024', '--cpus', 'goodbye!'\]/)
-
-      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 )
-        allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-        hosts = make_hosts(
-          {
-            :forwarded_ports => {
-              :http => {
-                :from => 10080,
-                :from_ip => '127.0.0.1',
-                :to => 80,
-                :to_ip => '0.0.0.0',
-                :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_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 )
-        allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-        hosts = make_hosts(
-            {
-                :forwarded_ports => {
-                    :http => {
-                        :from => 10080,
-                        :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/)
-      end
-
-      it "supports all to_ip" do
-        path = vagrant.instance_variable_get( :@vagrant_path )
-        allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-        hosts = make_hosts(
-            {
-                :forwarded_ports => {
-                    :http => {
-                        :from => 10080,
-                        :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/)
-      end
-
-      it "supports all protocol" do
-        path = vagrant.instance_variable_get( :@vagrant_path )
-        allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-
-        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/)
-
-      end
-    end
-
-    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
-      end
-
-      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
-        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 )
-
-      end
-
-      it "can copy to Administrator on windows" do
-        host = @hosts[0]
-        host[:platform] = 'windows'
-        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
-
-        # 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 )
-
-      end
-    end
-
-    it "can generate a ssh-config file" do
-      host = @hosts[0]
-      name = host.name
-      allow( Dir ).to receive( :chdir ).and_yield()
-      out = double( 'stdout' )
-      allow( out ).to receive( :read ).and_return("Host #{name}
-    HostName 127.0.0.1
-    User vagrant
-    Port 2222
-    UserKnownHostsFile /dev/null
-    StrictHostKeyChecking no
-    PasswordAuthentication no
-    IdentityFile /home/root/.vagrant.d/insecure_private_key
-    IdentitiesOnly yes")
-
-      wait_thr = OpenStruct.new
-      state = double( 'state' )
-      allow( state ).to receive( :success? ).and_return( true )
-      wait_thr.value = state
-
-      allow( Open3 ).to receive( :popen3 ).with( {"RUBYLIB"=>""}, 'vagrant', 'ssh-config', name ).and_return( [ "", out, "", wait_thr ])
-
-      file = double( 'file' )
-      allow( file ).to receive( :path ).and_return( '/path/sshconfig' )
-      allow( file ).to receive( :rewind ).and_return( true )
-
-      expect( Tempfile ).to receive( :new ).with( "#{host.name}").and_return( file )
-      expect( file ).to receive( :write ).with("Host ip.address.for.#{name}\n    HostName 127.0.0.1\n    User root\n    Port 2222\n    UserKnownHostsFile /dev/null\n    StrictHostKeyChecking no\n    PasswordAuthentication no\n    IdentityFile /home/root/.vagrant.d/insecure_private_key\n    IdentitiesOnly yes")
-
-      vagrant.set_ssh_config( host, 'root' )
-      expect( host['ssh'] ).to be === { :config => file.path }
-      expect( host['user']).to be === 'root'
-
-    end
-
-    describe "get_ip_from_vagrant_file" do
-      before :each do
-        allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
-        vagrant.make_vfile( @hosts )
-      end
-
-      it "can find the correct ip for the provided hostname" do
-        @hosts.each do |host|
-          expect( vagrant.get_ip_from_vagrant_file(host.name) ).to be === host[:ip]
-        end
-
-      end
-
-      it "returns nil if it is unable to find an ip" do
-        expect( vagrant.get_ip_from_vagrant_file("unknown") ).to be_nil
-      end
-
-      it "raises an error if no Vagrantfile is present" do
-        File.delete( vagrant.instance_variable_get( :@vagrant_file ) )
-        @hosts.each do |host|
-          expect{ vagrant.get_ip_from_vagrant_file(host.name) }.to raise_error RuntimeError, /No vagrant file found/
-        end
-      end
-    end
-
-    describe "provisioning and cleanup" do
-
-      before :each do
-        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
-        end
-        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
-        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
-        vagrant.provision
-      end
-
-      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 )
-      end
-
-      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
-      before :each do
-        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 ).not_to receive( :copy_ssh_to_root ).with( host, options ).once
-          expect( vagrant ).not_to receive( :set_ssh_config ).with( host, host_prev_name ).once
-        end
-        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
-        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
-        vagrant.provision
-      end
-
-      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