beaker 0.0.0 → 1.0.0

data/spec/beaker/hypervisor/aixer_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+
+module Beaker
+  describe Aixer do
+    let( :aixer) { Beaker::Aixer.new( @hosts, make_opts ) }
+
+    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 )
+    end
+
+    it "can provision a set of hosts" do
+      @hosts.each do |host|
+        Command.should_receive( :new ).with( "cd pe-aix && rake restore:#{host.name}" ).once
+
+      end
+
+      aixer.provision
+
+    end
+
+    it "does nothing for cleanup" do
+      Command.should_receive( :new ).never
+      Host.should_receive( :exec ).never
+
+      aixer.cleanup
+
+    end
+
+
+  end
+end

data/spec/beaker/hypervisor/blimper_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+require 'blimpy'
+
+module Beaker
+  describe Blimper do
+    let( :blimper ) { Beaker::Blimper.new( @hosts, make_opts ) }
+    let( :amispec ) { { "centos-5-x86-64-west" => { :image => { :pe => "ami-sekrit1" }, :region => "us-west-2" }, 
+                        "centos-6-x86-64-west" => { :image => { :pe => "ami-sekrit2" }, :region => "us-west-2" }, 
+                        "centos-7-x86-64-west" => { :image => { :pe => "ami-sekrit3" }, :region => "us-west-2" } }}
+
+    before :each do
+      @hosts = make_hosts( { :snapshot => :pe })
+      @hosts[0][:platform] = "centos-5-x86-64-west" 
+      @hosts[1][:platform] = "centos-6-x86-64-west" 
+      @hosts[2][:platform] = "centos-7-x86-64-west" 
+      blimper.instance_variable_set( :@blimpy, MockBlimpy )
+    end
+
+    it "can provision a set of hosts" do 
+      YAML.stub( :load_file ).and_return( {"AMI" => amispec} )
+      blimper.stub( :get_ip ) do |host|
+        host['ip']
+      end
+      blimper.stub( :get_domain_name ).and_return( 'domain' )
+      blimper.stub( :sleep ).and_return( true )
+
+      @hosts.each do |host|
+        blimper.should_receive( :set_etc_hosts ).with( host, "127.0.0.1\tlocalhost localhost.localdomain\nvm1.my.ip\tvm1\tvm1.domain\nvm2.my.ip\tvm2\tvm2.domain\nvm3.my.ip\tvm3\tvm3.domain\n" )
+      end
+
+      blimper.provision
+    end
+
+    it "calls fleet.destroy on cleanup" do
+      MockFleet.any_instance.should_receive( :add ).with( :aws ).exactly( @hosts.length ).times
+      MockFleet.any_instance.should_receive( :destroy ).once
+
+      blimper.cleanup
+    end
+
+    context "amiports" do
+
+      it "can set ports for database host" do
+        host = @hosts[0]
+        host[ :roles ] = [ "database" ]
+        
+        expect( blimper.amiports(host) ).to be === [ 22, 8080, 8081 ]
+
+      end
+
+      it "can set ports for master host" do
+        host = @hosts[0]
+        host[ :roles ] = [ "master" ]
+        
+        expect( blimper.amiports(host) ).to be === [ 22, 8140 ]
+
+      end
+
+      it "can set ports for dashboard host" do
+        host = @hosts[0]
+        host[ :roles ] = [ "dashboard" ]
+        
+        expect( blimper.amiports(host) ).to be === [ 22, 443 ]
+      end
+
+      it "can set ports for combined master/database/dashboard host" do
+        host = @hosts[0]
+        host[ :roles ] = [ "dashboard", "master", "database" ]
+        
+        expect( blimper.amiports(host) ).to be === [ 22, 8080, 8081, 8140, 443 ]
+      end
+    end
+
+
+  end
+
+end

data/spec/beaker/hypervisor/fusion_spec.rb

@@ -0,0 +1,26 @@
+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 )
+      Fusion.any_instance.stub( :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
+
+  end
+
+end

data/spec/beaker/hypervisor/hypervisor_spec.rb

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

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Beaker
+  describe Solaris do
+    let( :solaris) { Beaker::Solaris.new( @hosts, make_opts ) }
+
+    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 )
+    end
+
+    it "can provision a set of hosts" do
+      vmpath = "rpoooool/zs"
+      spath = "rpoooool/USER/z0"
+
+      @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
+      end
+
+      solaris.provision
+    end
+
+    it "does nothing for cleanup" do
+      Command.should_receive( :new ).never
+      Host.should_receive( :exec ).never
+
+      solaris.cleanup
+    end
+
+
+  end
+
+end

data/spec/beaker/hypervisor/vagrant_spec.rb

@@ -0,0 +1,105 @@
+require 'spec_helper'
+
+module Beaker
+  describe Vagrant do
+    let( :vagrant ) { Beaker::Vagrant.new( @hosts, make_opts ) }
+
+    before :each do
+      @hosts = make_hosts()
+    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" )
+
+      vagrant.make_vfile( @hosts )
+
+      expect( File.read( File.expand_path( File.join( path, "Vagrantfile") ) ) ).to be === "Vagrant.configure(\"2\") do |c|\n  c.vm.define 'vm1' do |v|\n    v.vm.hostname = 'vm1'\n    v.vm.box = 'vm1_of_my_box'\n    v.vm.box_url = 'http://address.for.my.box.vm1'\n    v.vm.base_mac = '0123456789'\n    v.vm.network :private_network, ip: \"ip.address.for.vm1\", :netmask => \"255.255.0.0\"\n  end\n  c.vm.define 'vm2' do |v|\n    v.vm.hostname = 'vm2'\n    v.vm.box = 'vm2_of_my_box'\n    v.vm.box_url = 'http://address.for.my.box.vm2'\n    v.vm.base_mac = '0123456789'\n    v.vm.network :private_network, ip: \"ip.address.for.vm2\", :netmask => \"255.255.0.0\"\n  end\n  c.vm.define 'vm3' do |v|\n    v.vm.hostname = 'vm3'\n    v.vm.box = 'vm3_of_my_box'\n    v.vm.box_url = 'http://address.for.my.box.vm3'\n    v.vm.base_mac = '0123456789'\n    v.vm.network :private_network, ip: \"ip.address.for.vm3\", :netmask => \"255.255.0.0\"\n  end\n  c.vm.provider :virtualbox do |vb|\n    vb.customize [\"modifyvm\", :id, \"--memory\", \"1024\"]\n  end\nend\n"
+    end
+
+    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
+      end
+
+      vagrant.hack_etc_hosts( @hosts )
+
+    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'
+
+        Command.should_receive( :new ).with("sudo su -c \"cp -r .ssh /root/.\"").once
+
+        vagrant.copy_ssh_to_root( host )
+
+      end
+
+      it "can copy to Administrator on windows" do
+        host = @hosts[0]
+        host[:platform] = 'windows'
+
+        Command.should_receive( :new ).with("sudo su -c \"cp -r .ssh /home/Administrator/.\"").once
+
+        vagrant.copy_ssh_to_root( host )
+
+      end
+    end
+
+    it "can generate a ssh-config file" do
+      host = @hosts[0]
+      name = host.name
+      Dir.stub( :chdir ).and_yield()
+
+      out = double( 'stdout' )
+      out.stub( :read ).and_return("Host #{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")
+
+      Open3.stub( :popen3 ).with( 'vagrant', 'ssh-config', host.name ).and_return( [ "", out ])
+
+      file = double( 'file' )
+      file.stub( :path ).and_return( '/path/sshconfig' )
+      file.stub( :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")
+
+      vagrant.set_ssh_config( host, 'root' )
+      expect( host['ssh'] ).to be === { :config => file.path }
+      expect( host['user']).to be === 'root'
+
+    end
+
+    it "can provision a set of hosts" do
+
+      vagrant.should_receive( :make_vfile ).with( @hosts ).once
+
+      vagrant.should_receive( :vagrant_cmd ).with( "halt" ).once
+      vagrant.should_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 ).once
+        vagrant.should_receive( :set_ssh_config ).with( host, host_prev_name ).once
+      end
+      vagrant.should_receive( :hack_etc_hosts ).with( @hosts ).once
+
+
+      vagrant.provision
+    end
+
+  end
+
+end

data/spec/beaker/hypervisor/vcloud_pooled_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module Beaker
+  describe VcloudPooled do
+
+    before :each do
+      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|
+        arg
+      end
+      Socket.stub( :getaddrinfo ).and_return( true )
+    end
+
+    describe "#provision" do
+
+      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 )
+        vcloud.provision
+
+        hosts = vcloud.instance_variable_get( :@vcloud_hosts )
+        hosts.each do | host |
+          expect( host['vmhostname'] ).to be === 'pool'
+        end
+        
+      end
+
+    end
+
+    describe "#cleanup" do
+
+      it "cleans up hosts in the pool" do
+        MockVsphereHelper.powerOn
+
+        vcloud = Beaker::VcloudPooled.new( make_hosts, make_opts )
+        vcloud.stub( :require ).and_return( true )
+        vcloud.stub( :sleep ).and_return( true )
+        vcloud.provision
+        vcloud.cleanup
+
+        hosts = vcloud.instance_variable_get( :@vcloud_hosts )
+        hosts.each do | host |
+          name = host.name
+          vm = MockVsphereHelper.find_vm( name )
+          expect( vm.runtime.powerState ).to be === "poweredOn" #handed back to the pool, stays on
+        end
+      end
+
+
+    end
+
+  end
+
+end

data/spec/beaker/hypervisor/vcloud_spec.rb

@@ -0,0 +1,70 @@
+require 'spec_helper'
+
+module Beaker
+  describe Vcloud do
+
+    before :each do
+      MockVsphereHelper.set_config( fog_file_contents )
+      MockVsphereHelper.set_vms( make_hosts() )
+      stub_const( "VsphereHelper", MockVsphereHelper )
+      stub_const( "Net", MockNet )
+      json = mock( 'json' )
+      json.stub( :parse ) do |arg| 
+        arg
+      end
+      stub_const( "JSON", json )
+      Socket.stub( :getaddrinfo ).and_return( true )
+    end
+
+    describe "#provision" do
+
+      it 'provisions hosts and add them to the pool' do
+        MockVsphereHelper.powerOff
+
+        opts = make_opts
+        opts[:pooling_api] = nil
+
+        vcloud = Beaker::Vcloud.new( make_hosts, opts )
+        vcloud.stub( :require ).and_return( true )
+        vcloud.stub( :sleep ).and_return( true )
+        vcloud.provision
+
+        hosts = vcloud.instance_variable_get( :@vcloud_hosts )
+        hosts.each do | host |
+          name = host['vmhostname']
+          vm = MockVsphereHelper.find_vm( name )
+          expect( vm.toolsRunningStatus ).to be === "guestToolsRunning"
+        end
+
+      end
+
+    end
+
+    describe "#cleanup" do
+
+      it "cleans up hosts not in the pool" do
+        MockVsphereHelper.powerOn
+
+        opts = make_opts
+        opts[:pooling_api] = nil
+
+        vcloud = Beaker::Vcloud.new( make_hosts, opts )
+        vcloud.stub( :require ).and_return( true )
+        vcloud.stub( :sleep ).and_return( true )
+        vcloud.provision
+        vcloud.cleanup
+
+        hosts = vcloud.instance_variable_get( :@vcloud_hosts )
+        vm_names = hosts.map {|h| h['vmhostname'] }.compact
+        vm_names.each do | name |
+          vm = MockVsphereHelper.find_vm( name )
+          expect( vm.runtime.powerState ).to be === "poweredOff"
+        end
+
+      end
+
+    end
+
+  end
+
+end