beaker-vagrant 0.1.0

data/lib/beaker/hypervisor/vagrant_custom.rb

@@ -0,0 +1,11 @@
+require 'beaker/hypervisor/vagrant'
+
+class Beaker::VagrantCustom < Beaker::Vagrant
+  def provision(provider = nil)
+    super
+  end
+
+  def make_vfile hosts, options = {}
+    FileUtils.cp(@options[:vagrantfile_path], @vagrant_file)
+  end
+end

data/lib/beaker/hypervisor/vagrant_fusion.rb

@@ -0,0 +1,17 @@
+require 'beaker/hypervisor/vagrant'
+
+class Beaker::VagrantFusion < Beaker::Vagrant
+  def provision(provider = 'vmware_fusion')
+    # By default vmware_fusion creates a .vagrant directory relative to the
+    # Vagrantfile path. That means beaker tries to scp the VM to itself unless
+    # we move the VM files elsewhere.
+    ENV['VAGRANT_VMWARE_CLONE_DIRECTORY'] = '~/.vagrant/vmware_fusion'
+    super
+  end
+
+  def self.provider_vfile_section(host, options)
+    "    v.vm.provider :vmware_fusion do |v|\n" +
+      "      v.vmx['memsize'] = '#{memsize(host, options)}'\n" +
+      "    end\n"
+  end
+end

data/lib/beaker/hypervisor/vagrant_libvirt.rb

@@ -0,0 +1,41 @@
+require 'beaker/hypervisor/vagrant'
+
+class Beaker::VagrantLibvirt < Beaker::Vagrant
+  @memory = nil
+  @cpu    = nil
+
+  class << self
+    attr_reader :memory
+  end
+
+  # Return a random mac address with colons
+  #
+  # @return [String] a random mac address
+  def randmac
+    "08:00:27:" + (1..3).map{"%0.2X"%rand(256)}.join(':')
+  end
+
+  def provision(provider = 'libvirt')
+    super
+  end
+
+  def self.provider_vfile_section(host, options)
+    "    v.vm.provider :libvirt do |node|\n" +
+      "      node.cpus = #{cpus(host, options)}\n" +
+      "      node.memory = #{memsize(host, options)}\n" +
+      build_options_str(options) +
+      "    end\n"
+  end
+
+  def self.build_options_str(options)
+    other_options_str = ''
+    if options['libvirt']
+      other_options = []
+      options['libvirt'].each do |k, v|
+        other_options << "      node.#{k} = '#{v}'"
+      end
+      other_options_str = other_options.join("\n")
+    end
+    "#{other_options_str}\n"
+  end
+end

data/lib/beaker/hypervisor/vagrant_parallels.rb

@@ -0,0 +1,18 @@
+require 'beaker/hypervisor/vagrant'
+
+class Beaker::VagrantParallels < Beaker::Vagrant
+  def provision(provider = 'parallels')
+    super
+  end
+
+  def self.provider_vfile_section(host, options)
+    provider_section  = ""
+    provider_section << "    v.vm.provider :parallels do |prl|\n"
+    provider_section << "      prl.optimize_power_consumption = false\n"
+    provider_section << "      prl.memory = '#{memsize(host,options)}'\n"
+    provider_section << "      prl.update_guest_tools = false\n" if options[:prl_update_guest_tools] == 'disable'
+    provider_section << "    end\n"
+
+    provider_section
+  end
+end

data/lib/beaker/hypervisor/vagrant_virtualbox.rb

@@ -0,0 +1,76 @@
+require 'beaker/hypervisor/vagrant'
+
+class Beaker::VagrantVirtualbox < Beaker::Vagrant
+  def provision(provider = 'virtualbox')
+    super
+  end
+
+  # Generate a VM customization string
+  def self.vb_customize(command, args)
+    "      vb.customize ['#{command}', #{args.map{|a| "'#{a.to_s}'"}.join(", ")}]\n"
+  end
+
+  # Generate a VM customization string for the current VM
+  def self.vb_customize_vm(command, args)
+    "      vb.customize ['#{command}', :id, #{args.map{|a| "'#{a.to_s}'"}.join(", ")}]\n"
+  end
+
+  def self.provider_vfile_section(host, options)
+    # Allow memory and CPUs to be set at a per node level or overall, and take the most specific setting
+    provider_section  = ""
+    provider_section << "    v.vm.provider :virtualbox do |vb|\n"
+    provider_section << "      vb.customize ['modifyvm', :id, '--memory', '#{memsize(host,options)}', '--cpus', '#{cpus(host,options)}']\n"
+    provider_section << "      vb.vbguest.auto_update = false" if options[:vbguest_plugin] == 'disable'
+
+    # Guest volume support
+    # - Creates a new AHCI controller with the requisite number of ports,
+    #   the default controller is limited in its number of supported ports (2).
+    #   The AHCI emulation is generic enough for acceptance testing, and
+    #   presents the devices as SCSI devices in /sys/class/scsi_disk.
+    # - Creates the defined volumes in beaker's temporary folder and attaches
+    #   them to the controller in order starting at port 0.  This presents disks
+    #   as 2:0:0:0, 3:0:0:0 ... much like you'd see on commercial storage boxes
+    if host['volumes']
+      provider_section << self.vb_customize_vm('storagectl', [
+        '--name', 'SATA Controller',
+        '--add', 'sata',
+        '--controller', 'IntelAHCI',
+        '--portcount', host['volumes'].length
+      ])
+      host['volumes'].keys.each_with_index do |volume, index|
+        volume_path = "#{host.name}-#{volume}.vdi"
+        provider_section << self.vb_customize('createhd', [
+          '--filename', volume_path,
+          '--size', host['volumes'][volume]['size'],
+        ])
+        provider_section << self.vb_customize_vm('storageattach', [
+          '--storagectl', 'SATA Controller',
+          '--port', index,
+          '--device', 0,
+          '--type', 'hdd',
+          '--medium', volume_path,
+        ])
+      end
+    end
+
+    provider_section << "      vb.customize [\"modifyvm\", :id, \"--natdnshostresolver1\", \"#{host['natdns']}\"]\n" unless host['natdns'].nil?
+
+    provider_section << "      vb.customize [\"modifyvm\", :id, \"--natdnsproxy1\", \"#{host['natdns']}\"]\n" unless host['natdns'].nil?
+
+    provider_section << "      vb.gui = true\n" unless host['vb_gui'].nil?
+
+    provider_section << "      [\"modifyvm\", :id, \"--cpuidset\", \"1\",\"000206a7\",\"02100800\",\"1fbae3bf\",\"bfebfbff\"\]" if /osx/i.match(host['platform'])
+
+    if host['disk_path']
+      unless File.exist?(host['disk_path'])
+        host['disk_path'] = File.join(host['disk_path'], "#{host.name}.vmdk")
+        provider_section << "      vb.customize ['createhd', '--filename', '#{host['disk_path']}', '--size', #{host['disk_size'] ||= 5 * 1024}, '--format', 'vmdk']\n"
+      end
+      provider_section << "      vb.customize ['storageattach', :id, '--storagectl', 'SATA Controller', '--port', 1, '--device', 0, '--type', 'hdd', '--medium','#{host['disk_path']}']\n"
+    end
+
+    provider_section << "    end\n"
+
+    provider_section
+  end
+end

data/lib/beaker/hypervisor/vagrant_workstation.rb

@@ -0,0 +1,13 @@
+require 'beaker/hypervisor/vagrant'
+
+class Beaker::VagrantWorkstation < Beaker::Vagrant
+  def provision(provider = 'vmware_workstation')
+    super
+  end
+
+  def self.provider_vfile_section(host, options)
+    "    v.vm.provider :vmware_workstation do |v|\n" +
+      "      v.vmx['memsize'] = '#{memsize(host,options)}'\n" +
+      "    end\n"
+  end
+end

data/spec/beaker/hypervisor/vagrant_custom_spec.rb

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,61 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,479 @@
+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