beaker 1.21.0 → 2.0.0

data/spec/beaker/hypervisor/hypervisor_spec.rb.orig

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+module Beaker
+  describe Hypervisor do
+    let( :hypervisor ) { Beaker::Hypervisor }
+
+    it "creates an aix hypervisor for aix hosts" do
+      aix = double( 'aix' )
+      aix.stub( :provision ).and_return( true )
+
+      Aixer.should_receive( :new ).once.and_return( aix )
+      expect( hypervisor.create( 'aix', [], make_opts() ) ).to be === aix
+    end
+
+    it "creates a solaris hypervisor for solaris hosts" do
+      solaris = double( 'solaris' )
+      solaris.stub( :provision ).and_return( true )
+      Solaris.should_receive( :new ).once.and_return( solaris )
+      expect( hypervisor.create( 'solaris', [], make_opts() ) ).to be === solaris
+    end
+
+    it "creates a vsphere hypervisor for vsphere hosts" do
+      vsphere = double( 'vsphere' )
+      vsphere.stub( :provision ).and_return( true )
+      Vsphere.should_receive( :new ).once.and_return( vsphere )
+      expect( hypervisor.create( 'vsphere', [], make_opts() ) ).to be === vsphere
+    end
+
+    it "creates a fusion hypervisor for fusion hosts" do
+      fusion = double( 'fusion' )
+      fusion.stub( :provision ).and_return( true )
+      Fusion.should_receive( :new ).once.and_return( fusion )
+      expect( hypervisor.create( 'fusion', [], make_opts() ) ).to be === fusion
+    end
+
+    it "creates a vcloudpooled hypervisor for vcloud hosts that are pooled" do
+      vcloud = double( 'vcloud' )
+      vcloud.stub( :provision ).and_return( true )
+      VcloudPooled.should_receive( :new ).once.and_return( vcloud )
+      expect( hypervisor.create( 'vcloud', [], make_opts().merge( { 'pooling_api' => true } ) ) ).to be === vcloud
+    end
+
+    it "creates a vcloud hypervisor for vcloud hosts that are not pooled" do
+      vcloud = double( 'vcloud' )
+      vcloud.stub( :provision ).and_return( true )
+      Vcloud.should_receive( :new ).once.and_return( vcloud )
+      expect( hypervisor.create( 'vcloud', [], make_opts().merge( { 'pooling_api' => false } ) ) ).to be === vcloud
+    end
+
+    it "creates a vagrant hypervisor for vagrant hosts" do
+      vagrant = double( 'vagrant' )
+      vagrant.stub( :provision ).and_return( true )
+      Vagrant.should_receive( :new ).once.and_return( vagrant )
+      expect( hypervisor.create( 'vagrant', [], make_opts() ) ).to be === vagrant
+    end
+
+    it "creates a vagrant_fusion hypervisor for vagrant vmware fusion hosts" do
+      vagrant = double( 'vagrant_fusion' )
+      vagrant.stub( :provision ).and_return( true )
+      VagrantFusion.should_receive( :new ).once.and_return( vagrant )
+      expect( hypervisor.create( 'vagrant_fusion', [], make_opts() ) ).to be === vagrant
+    end
+
+    it "creates a vagrant_virtualbox hypervisor for vagrant virtualbox hosts" do
+      vagrant = double( 'vagrant_virtualbox' )
+      vagrant.stub( :provision ).and_return( true )
+      VagrantVirtualbox.should_receive( :new ).once.and_return( vagrant )
+      expect( hypervisor.create( 'vagrant_virtualbox', [], make_opts() ) ).to be === vagrant
+    end
+
+    it "creates a blimpy hypervisor for blimpy hosts" do
+      blimpy = double( 'blimpy' )
+      blimpy.stub( :provision ).and_return( true )
+      Blimper.should_receive( :new ).once.and_return( blimpy )
+      expect( hypervisor.create( 'blimpy', [], make_opts() ) ).to be === blimpy
+    end
+
+
+  end
+end

data/spec/beaker/hypervisor/solaris_spec.rb

@@ -6,9 +6,9 @@ module Beaker
 
     before :each do
       @hosts = make_hosts()
-      File.stub( :exists? ).and_return( true )
-      YAML.stub( :load_file ).and_return( fog_file_contents )
-      Host.any_instance.stub( :exec ).and_return( true )
+      allow( File ).to receive( :exists? ).and_return( true )
+      allow( YAML ).to receive( :load_file ).and_return( fog_file_contents )
+      allow_any_instance_of( Host ).to receive( :exec ).and_return( true )
     end
 
     it "can provision a set of hosts" do
@@ -18,17 +18,17 @@ module Beaker
       @hosts.each do |host|
         vm_name = host['vmname'] || host.name
         snapshot = host['snapshot']
-        Command.should_receive( :new ).with("sudo /sbin/zfs rollback -Rf #{vmpath}/#{vm_name}@#{snapshot}").once
-        Command.should_receive( :new ).with("sudo /sbin/zfs rollback -Rf #{vmpath}/#{vm_name}/#{spath}@#{snapshot}").once
-        Command.should_receive( :new ).with("sudo /sbin/zoneadm -z #{vm_name} boot").once
+        expect( Command ).to receive( :new ).with("sudo /sbin/zfs rollback -Rf #{vmpath}/#{vm_name}@#{snapshot}").once
+        expect( Command ).to receive( :new ).with("sudo /sbin/zfs rollback -Rf #{vmpath}/#{vm_name}/#{spath}@#{snapshot}").once
+        expect( Command ).to receive( :new ).with("sudo /sbin/zoneadm -z #{vm_name} boot").once
       end
 
       solaris.provision
     end
 
     it "does nothing for cleanup" do
-      Command.should_receive( :new ).never
-      Host.should_receive( :exec ).never
+      expect( Command ).to receive( :new ).never
+      expect( Host ).to receive( :exec ).never
 
       solaris.cleanup
     end

data/spec/beaker/hypervisor/vagrant_fusion_spec.rb

@@ -11,20 +11,18 @@ describe Beaker::VagrantFusion do
   it "uses the vmware_fusion provider for provisioning" do
     @hosts.each do |host|
       host_prev_name = host['user']
-      vagrant.should_receive( :set_ssh_config ).with( host, 'vagrant' ).once
-      vagrant.should_receive( :copy_ssh_to_root ).with( host, options ).once
-      vagrant.should_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
-    vagrant.should_receive( :hack_etc_hosts ).with( @hosts, options ).once
-    FakeFS.activate!
-    vagrant.should_receive( :vagrant_cmd ).with( "up --provider vmware_fusion" ).once
+    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
-    FakeFS.activate!
     path = vagrant.instance_variable_get( :@vagrant_path )
-    vagrant.stub( :randmac ).and_return( "0123456789" )
+    allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
 
     vagrant.make_vfile( @hosts )
 

data/spec/beaker/hypervisor/vagrant_libvirt_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+describe Beaker::VagrantLibvirt do
+  let( :options ) { make_opts.merge({ :hosts_file => 'sample.cfg', 'logger' => double().as_null_object }) }
+  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
+
+  it "can make a Vagranfile for a set of hosts" do
+    FakeFS.activate!
+    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 :libvirt})
+  end
+end

data/spec/beaker/hypervisor/vagrant_spec.rb

@@ -10,18 +10,16 @@ module Beaker
     end
 
     it "stores the vagrant file in $WORKINGDIR/.vagrant/beaker_vagrant_files/sample.cfg" do
-      FakeFS.activate!
-      vagrant.stub( :randmac ).and_return( "0123456789" )
+      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 Vagranfile for a set of hosts" do
-      FakeFS.activate!
+    it "can make a Vagrantfile for a set of hosts" do
       path = vagrant.instance_variable_get( :@vagrant_path )
-      vagrant.stub( :randmac ).and_return( "0123456789" )
+      allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
 
       vagrant.make_vfile( @hosts )
 
@@ -66,9 +64,8 @@ EOF
     end
 
     it "generates a valid windows config" do
-      FakeFS.activate!
       path = vagrant.instance_variable_get( :@vagrant_path )
-      vagrant.stub( :randmac ).and_return( "0123456789" )
+      allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
       @hosts[0][:platform] = 'windows'
 
       vagrant.make_vfile( @hosts )
@@ -88,9 +85,8 @@ EOF
     end
 
     it "uses the memsize defined per vagrant host" do
-      FakeFS.activate!
       path = vagrant.instance_variable_get( :@vagrant_path )
-      vagrant.stub( :randmac ).and_return( "0123456789" )
+      allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
 
       vagrant.make_vfile( @hosts, {'vagrant_memsize' => 'hello!'} )
 
@@ -105,7 +101,7 @@ EOF
     it "can generate a new /etc/hosts file referencing each host" do
 
       @hosts.each do |host|
-        vagrant.should_receive( :set_etc_hosts ).with( host, "127.0.0.1\tlocalhost localhost.localdomain\nip.address.for.vm1\tvm1\nip.address.for.vm2\tvm2\nip.address.for.vm3\tvm3\n" ).once
+        expect( vagrant ).to receive( :set_etc_hosts ).with( host, "127.0.0.1\tlocalhost localhost.localdomain\nip.address.for.vm1\tvm1\nip.address.for.vm2\tvm2\nip.address.for.vm3\tvm3\n" ).once
       end
 
       vagrant.hack_etc_hosts( @hosts, options )
@@ -118,7 +114,7 @@ EOF
         host = @hosts[0]
         host[:platform] = 'unix'
 
-        Command.should_receive( :new ).with("sudo su -c \"cp -r .ssh /root/.\"").once
+        expect( Command ).to receive( :new ).with("sudo su -c \"cp -r .ssh /root/.\"").once
 
         vagrant.copy_ssh_to_root( host, options )
 
@@ -128,8 +124,8 @@ EOF
         host = @hosts[0]
         host[:platform] = 'windows'
 
-        Command.should_receive( :new ).with("cp -r .ssh /cygdrive/c/Users/Administrator/.").once
-        Command.should_receive( :new ).with("chown -R Administrator /cygdrive/c/Users/Administrator/.ssh").once
+        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
 
         vagrant.copy_ssh_to_root( host, options )
 
@@ -139,9 +135,9 @@ EOF
     it "can generate a ssh-config file" do
       host = @hosts[0]
       name = host.name
-      Dir.stub( :chdir ).and_yield()
-
-      vagrant.should_receive(:`).and_return("Host #{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
@@ -151,12 +147,19 @@ EOF
     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( 'vagrant', 'ssh-config', name ).and_return( [ "", out, "", wait_thr ])
+
       file = double( 'file' )
-      file.stub( :path ).and_return( '/path/sshconfig' )
-      file.stub( :rewind ).and_return( true )
+      allow( file ).to receive( :path ).and_return( '/path/sshconfig' )
+      allow( file ).to receive( :rewind ).and_return( true )
 
-      Tempfile.should_receive( :new ).with( "#{host.name}").and_return( file ) 
-      file.should_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")
+      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 }
@@ -166,8 +169,7 @@ EOF
 
     describe "get_ip_from_vagrant_file" do
       before :each do
-        FakeFS.activate!
-        vagrant.stub( :randmac ).and_return( "0123456789" )
+        allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
         vagrant.make_vfile( @hosts )
       end
 
@@ -195,33 +197,32 @@ EOF
     describe "provisioning and cleanup" do
 
       before :each do
-        FakeFS.activate!
-        vagrant.should_receive( :vagrant_cmd ).with( "up" ).once
+        expect( vagrant ).to receive( :vagrant_cmd ).with( "up" ).once
         @hosts.each do |host|
           host_prev_name = host['user']
-          vagrant.should_receive( :set_ssh_config ).with( host, 'vagrant' ).once
-          vagrant.should_receive( :copy_ssh_to_root ).with( host, options ).once
-          vagrant.should_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
-        vagrant.should_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 )
-        vagrant.should_receive( :make_vfile ).with( @hosts, options ).once
-        vagrant.should_receive( :vagrant_cmd ).with( "destroy --force" ).never
+        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 )
-        vagrant.should_receive( :vagrant_cmd ).with( "destroy --force" ).once
+        expect( vagrant ).to receive( :vagrant_cmd ).with( "destroy --force" ).once
         vagrant.provision
       end
 
       it "can cleanup" do
-        vagrant.should_receive( :vagrant_cmd ).with( "destroy --force" ).once
-        FileUtils.should_receive( :rm_rf ).once
+        expect( vagrant ).to receive( :vagrant_cmd ).with( "destroy --force" ).once
+        expect( FileUtils ).to receive( :rm_rf ).once
 
         vagrant.provision
         vagrant.cleanup

data/spec/beaker/hypervisor/vagrant_virtualbox_spec.rb

@@ -11,24 +11,34 @@ describe Beaker::VagrantVirtualbox do
   it "uses the virtualbox provider for provisioning" do
     @hosts.each do |host|
       host_prev_name = host['user']
-      vagrant.should_receive( :set_ssh_config ).with( host, 'vagrant' ).once
-      vagrant.should_receive( :copy_ssh_to_root ).with( host, options ).once
-      vagrant.should_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
-    vagrant.should_receive( :hack_etc_hosts ).with( @hosts, options ).once
-    FakeFS.activate!
-    vagrant.should_receive( :vagrant_cmd ).with( "up --provider virtualbox" ).once
+    expect( vagrant ).to receive( :hack_etc_hosts ).with( @hosts, options ).once
+    expect( vagrant ).to receive( :vagrant_cmd ).with( "up --provider virtualbox" ).once
     vagrant.provision
   end
 
   it "can make a Vagranfile for a set of hosts" do
-    FakeFS.activate!
     path = vagrant.instance_variable_get( :@vagrant_path )
-    vagrant.stub( :randmac ).and_return( "0123456789" )
+    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 :virtualbox do |vb|\n      vb.customize ['modifyvm', :id, '--memory', '1024']\n    end})
   end
+
+  it "can disable the vb guest plugin" do
+    options.merge!({ :vbguest_plugin => 'disable' })
+
+    vfile_section = vagrant.class.provider_vfile_section( @hosts.first, options )
+
+    match = vfile_section.match(/vb.vbguest.auto_update = false/)
+
+    expect( match ).to_not be nil
+
+  end
+
 end

data/spec/beaker/hypervisor/vagrant_workstation_spec.rb

@@ -11,20 +11,18 @@ describe Beaker::VagrantWorkstation do
   it "uses the vmware_workstation provider for provisioning" do
     @hosts.each do |host|
       host_prev_name = host['user']
-      vagrant.should_receive( :set_ssh_config ).with( host, 'vagrant' ).once
-      vagrant.should_receive( :copy_ssh_to_root ).with( host, options ).once
-      vagrant.should_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
-    vagrant.should_receive( :hack_etc_hosts ).with( @hosts, options ).once
-    FakeFS.activate!
-    vagrant.should_receive( :vagrant_cmd ).with( "up --provider vmware_workstation" ).once
+    expect( vagrant ).to receive( :hack_etc_hosts ).with( @hosts, options ).once
+    expect( vagrant ).to receive( :vagrant_cmd ).with( "up --provider vmware_workstation" ).once
     vagrant.provision
   end
 
   it "can make a Vagranfile for a set of hosts" do
-    FakeFS.activate!
     path = vagrant.instance_variable_get( :@vagrant_path )
-    vagrant.stub( :randmac ).and_return( "0123456789" )
+    allow( vagrant ).to receive( :randmac ).and_return( "0123456789" )
 
     vagrant.make_vfile( @hosts )
 

data/spec/beaker/hypervisor/vcloud_pooled_spec.rb

@@ -7,12 +7,12 @@ module Beaker
       vms = make_hosts()
       MockVsphereHelper.set_config( fog_file_contents )
       MockVsphereHelper.set_vms( vms )
-      stub_const( "VsphereHelper", MockVsphereHelper )
-      stub_const( "Net", MockNet )
-      JSON.stub( :parse ) do |arg|
+     stub_const( "VsphereHelper", MockVsphereHelper )
+     stub_const( "Net", MockNet )
+      allow( JSON ).to receive( :parse ) do |arg|
         arg
       end
-      Socket.stub( :getaddrinfo ).and_return( true )
+      allow( Socket ).to receive( :getaddrinfo ).and_return( true )
     end
 
     describe '#get_template_url' do
@@ -46,8 +46,8 @@ module Beaker
       it 'provisions hosts from the pool' do 
 
         vcloud = Beaker::VcloudPooled.new( make_hosts, make_opts )
-        vcloud.stub( :require ).and_return( true )
-        vcloud.stub( :sleep ).and_return( true )
+        allow( vcloud ).to receive( :require ).and_return( true )
+        allow( vcloud ).to receive( :sleep ).and_return( true )
         vcloud.provision
 
         hosts = vcloud.instance_variable_get( :@hosts )
@@ -65,8 +65,8 @@ module Beaker
         MockVsphereHelper.powerOn
 
         vcloud = Beaker::VcloudPooled.new( make_hosts, make_opts )
-        vcloud.stub( :require ).and_return( true )
-        vcloud.stub( :sleep ).and_return( true )
+        allow( vcloud ).to receive( :require ).and_return( true )
+        allow( vcloud ).to receive( :sleep ).and_return( true )
         vcloud.provision
         vcloud.cleanup