beaker 0.0.0 → 1.0.0

data/spec/beaker/hypervisor/vsphere_helper_spec.rb

@@ -0,0 +1,162 @@
+require 'spec_helper'
+
+module Beaker
+  describe VsphereHelper do
+    let( :logger )         { double('logger').as_null_object }
+    let( :vInfo )          { { :server => "vsphere.labs.net", :user => "vsphere@labs.com", :pass => "supersekritpassword" } }
+    let( :vsphere_helper ) { VsphereHelper.new ( vInfo.merge( { :logger => logger } ) ) }
+    let( :snaplist )       { { 'snap1' => { 'snap1sub1' => nil , 
+                                            'snap1sub2' => nil }, 
+                               'snap2' => nil,
+                               'snap3' => { 'snap3sub1' => nil , 
+                                            'snap3sub2' => nil ,
+                                            'snap3sub3' => nil } } }
+    let( :vms )            {  [ MockRbVmomiVM.new( 'mockvm1', snaplist ), 
+                                MockRbVmomiVM.new( 'mockvm2', snaplist ), 
+                                MockRbVmomiVM.new( 'mockvm3', snaplist ) ] }
+
+                                                
+
+    before :each do
+      stub_const( "RbVmomi", MockRbVmomi )
+    end
+
+    describe "#load_config" do 
+
+      it 'can load a .fog file' do
+        File.stub( :exists? ).and_return( true )
+        YAML.stub( :load_file ).and_return( fog_file_contents )
+
+        expect( VsphereHelper.load_config ).to be === vInfo
+
+      end
+
+      it 'raises an error when the .fog file is missing' do
+        File.stub( :exists? ).and_return( false )
+
+        expect{ VsphereHelper.load_config }.to raise_error( ArgumentError )
+
+      end
+
+    end
+
+   describe "#find_snapshot" do
+     it 'can find a given snapshot name' do
+       mockvm = MockRbVmomiVM.new( 'mockvm', snaplist )
+
+       expect( vsphere_helper.find_snapshot( mockvm, 'snap2' ) ).to be === mockvm.get_snapshot( 'snap2' )
+
+     end
+
+   end
+
+   describe "#find_customization" do
+     it 'returns the customization spec' do
+
+       expect( vsphere_helper.find_customization( 'name' ) ).to be === true
+
+     end
+
+   end
+
+   describe "#find_vms" do
+     it 'finds the list of vms' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       connection.set_info( vms )
+
+       expect( vsphere_helper.find_vms( 'mockvm1' ) ).to be === {vms[0].name => vms[0]}
+     end
+
+     it 'returns {} when no vm is found' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       connection.set_info( vms )
+
+       expect( vsphere_helper.find_vms( 'novm' ) ).to be === {}
+     end
+
+   end
+
+   describe "#find_datastore" do
+     it 'finds the datastore from the connection object' do
+       expect(vsphere_helper.find_datastore( 'datastorename' ) ).to be === true
+     end
+
+   end
+
+   describe "#find_folder" do
+     it 'can find a folder in the datacenter' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+
+       expect(vsphere_helper.find_folder( 'root' ) ).to be === connection.serviceInstance.find_datacenter.vmFolder
+     end
+
+   end
+
+   describe "#find_pool" do
+     it 'can find a pool in a folder in the datacenter' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       connection.serviceInstance.find_datacenter.hostFolder = MockRbVmomi::VIM::Folder.new
+       connection.serviceInstance.find_datacenter.hostFolder.name = "/root"
+
+       expect(vsphere_helper.find_pool( 'root' ) ).to be === connection.serviceInstance.find_datacenter.hostFolder
+
+     end
+     it 'can find a pool in a clustercomputeresource in the datacenter' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       connection.serviceInstance.find_datacenter.hostFolder = MockRbVmomi::VIM::ClusterComputeResource.new
+       connection.serviceInstance.find_datacenter.hostFolder.name = "/root"
+
+       expect(vsphere_helper.find_pool( 'root' ) ).to be === connection.serviceInstance.find_datacenter.hostFolder
+
+     end
+     it 'can find a pool in a resourcepool in the datacenter' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       connection.serviceInstance.find_datacenter.hostFolder = MockRbVmomi::VIM::ResourcePool.new
+       connection.serviceInstance.find_datacenter.hostFolder.name = "/root"
+
+       expect(vsphere_helper.find_pool( 'root' ) ).to be === connection.serviceInstance.find_datacenter.hostFolder
+     end
+
+   end
+
+   describe "#wait_for_tasks" do
+     it "can wait for tasks to error" do
+       vsphere_helper.stub( :sleep ).and_return( true )
+       vms.each do |vm|
+         vm.info.state = 'error'
+       end
+
+       expect(vsphere_helper.wait_for_tasks( vms, 0, 5 ) ).to be === vms
+     end
+
+     it "can wait for tasks to succeed" do
+       vsphere_helper.stub( :sleep ).and_return( true )
+       vms.each do |vm|
+         vm.info.state = 'success'
+       end
+
+       expect(vsphere_helper.wait_for_tasks( vms, 0, 5 ) ).to be === vms
+     end
+
+     it "errors when tasks fail to error/success before timing out" do
+       vsphere_helper.stub( :sleep ).and_return( true )
+       vms.each do |vm|
+         vm.info.state = 'nope'
+       end
+
+       expect{ vsphere_helper.wait_for_tasks( vms, 0, 5 ) }.to raise_error
+     end
+
+   end
+
+   describe "#close" do
+     it 'closes the connection' do
+       connection = vsphere_helper.instance_variable_get( :@connection )
+       connection.should_receive( :close ).once
+       
+       vsphere_helper.close
+     end
+   end
+
+ end
+end

data/spec/beaker/hypervisor/vsphere_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+module Beaker
+  describe Vsphere do
+
+    before :each do
+      MockVsphereHelper.set_config( fog_file_contents )
+      MockVsphereHelper.set_vms( make_hosts() )
+      stub_const( "VsphereHelper", MockVsphereHelper )
+    end
+
+    describe "#provision" do
+
+      it 'provisions hosts' do 
+        MockVsphereHelper.powerOff
+        vsphere = Beaker::Vsphere.new( make_hosts(), make_opts )
+
+        vsphere.provision
+
+        hosts =  vsphere.instance_variable_get( :@vsphere_hosts )
+        hosts.each do |host|
+          expect( MockVsphereHelper.find_vm( host.name ).powerState ) == "poweredOn"
+        end
+        
+      end
+
+      it 'raises an error if a vm is missing in Vsphere' do
+        MockVsphereHelper.powerOff
+        hosts = make_hosts()
+        hosts[0][:vmname] = 'unknown'
+        vsphere = Beaker::Vsphere.new( hosts, make_opts )
+
+        expect{ vsphere.provision }.to raise_error
+
+      end
+
+      it 'raises an error if a vm does not have a given snapshot name' do
+        MockVsphereHelper.powerOff
+        hosts = make_hosts()
+        hosts[0]["snapshot"] = 'unknown'
+        vsphere = Beaker::Vsphere.new( hosts, make_opts )
+
+        expect{ vsphere.provision }.to raise_error
+
+      end
+
+    end
+
+    describe "#cleanup" do
+
+      it "cleans up" do
+        MockVsphereHelper.powerOn
+        vsphere = Beaker::Vsphere.new( make_hosts(), make_opts )
+        vsphere.cleanup
+
+        hosts =  vsphere.instance_variable_get( :@vsphere_hosts )
+        hosts.each do |host|
+          expect( MockVsphereHelper.find_vm( host.name ).powerState ) == "poweredOff"
+        end
+      end
+
+      it 'raises an error if a vm is missing in Vsphere' do
+        MockVsphereHelper.powerOn
+        hosts = make_hosts()
+        hosts[0][:vmname] = 'unknown'
+        vsphere = Beaker::Vsphere.new( hosts, make_opts )
+
+        expect{ vsphere.cleanup }.to raise_error
+
+      end
+
+    end
+
+  end
+
+end

data/spec/beaker/options/command_line_parser_spec.rb

@@ -0,0 +1,25 @@
+require "spec_helper"
+
+module Beaker
+  module Options
+    describe CommandLineParser do
+
+      let(:parser) {Beaker::Options::CommandLineParser.new}
+      let(:test_opts) {["-h", "vcloud.cfg", "--debug", "--tests", "test.rb", "--help"]}
+      let(:full_opts) {["--hosts", "host.cfg", "--options", "opts_file", "--type", "pe", "--helper", "path_to_helper", "--load-path", "load_path", "--tests", "test1.rb,test2.rb,test3.rb", "--pre-suite", "pre_suite.rb", "--post-suite", "post_suite.rb", "--no-provision", "--preserve-hosts", "--root-keys", "--keyfile", "../.ssh/id_rsa", "--install", "gitrepopath", "-m", "module", "-q", "--no-xml", "--dry-run", "--no-ntp", "--repo-proxy", "--add-el-extras", "--config", "anotherfile.cfg", "--fail-mode", "fast", "--no-color"]}
+
+      it "can correctly read command line input" do
+        expect(parser.parse!(test_opts)).to be === {:hosts_file=>"vcloud.cfg", :debug=>true, :tests=>"test.rb", :help=>true}
+      end
+
+      it "supports all our command line options" do
+        expect(parser.parse!(full_opts)).to be === {:hosts_file=>"anotherfile.cfg", :options_file=>"opts_file", :type=>"pe", :helper=>"path_to_helper", :load_path=>"load_path", :tests=>"test1.rb,test2.rb,test3.rb", :pre_suite=>"pre_suite.rb", :post_suite=>"post_suite.rb", :provision=>false, :preserve_hosts=>true, :root_keys=>true, :keyfile=>"../.ssh/id_rsa", :install=>"gitrepopath", :modules=>"module", :quiet=>true, :xml=>false, :dry_run=>true, :timesync=>false, :repo_proxy=>true, :add_el_extras=>true, :fail_mode=>"fast", :color=>false}
+      end
+
+      it "can produce a usage description" do
+        expect{parser.usage}.to_not raise_error 
+      end
+
+    end
+  end
+end

data/spec/beaker/options/data/LATEST

@@ -0,0 +1 @@
+3.0.0

data/spec/beaker/options/data/badyaml.cfg

@@ -0,0 +1,21 @@
+HOSTS:
+  pe-ubuntu-lucid:
+    roles:
+      - agent
+      - dashboard
+      - database
+      - master
+    vmname : pe-ubuntu-lucid
+    platform: ubuntu-10.04-i386
+    snapshot : clean-w-keys
+    hypervisor : fusion
+  pe-centos6:
+    roles:
+      - agent
+    vmname : pe-centos6
+    platform: el-6-i386
+    hypervisor : fusion
+    snapshot *** clean-w-keys
+CONFIG:
+  nfs_server: none
+  consoleport: 443

data/spec/beaker/options/data/hosts.cfg

@@ -0,0 +1,21 @@
+HOSTS:
+  pe-ubuntu-lucid:
+    roles:
+      - agent
+      - dashboard
+      - database
+      - master
+    vmname : pe-ubuntu-lucid
+    platform: ubuntu-10.04-i386
+    snapshot : clean-w-keys
+    hypervisor : fusion
+  pe-centos6:
+    roles:
+      - agent
+    vmname : pe-centos6
+    platform: el-6-i386
+    hypervisor : fusion
+    snapshot: clean-w-keys
+CONFIG:
+  nfs_server: none
+  consoleport: 443

data/spec/beaker/options/data/opts.txt

@@ -0,0 +1,6 @@
+{
+  :debug     => true,
+  :tests     => 'test.rb',
+  :pre_suite => [ 'pre-suite.rb'],
+  :post_suite => "post_suite1.rb,post_suite2.rb",
+}

data/spec/beaker/options/hosts_file_parser_spec.rb

@@ -0,0 +1,30 @@
+require "spec_helper"
+
+module Beaker
+  module Options
+    describe HostsFileParser do
+
+      let(:parser) {HostsFileParser}
+      let(:filepath) {File.join(File.expand_path(File.dirname(__FILE__)), "data", "hosts.cfg")}
+
+      it "can correctly read a host file" do
+        FakeFS.deactivate!
+        config = parser.parse_hosts_file(filepath)
+        expect(config).to be === {:HOSTS=>{:"pe-ubuntu-lucid"=>{:roles=>["agent", "dashboard", "database", "master"], :vmname=>"pe-ubuntu-lucid", :platform=>"ubuntu-10.04-i386", :snapshot=>"clean-w-keys", :hypervisor=>"fusion"}, :"pe-centos6"=>{:roles=>["agent"], :vmname=>"pe-centos6", :platform=>"el-6-i386", :hypervisor=>"fusion", :snapshot=>"clean-w-keys"}}, :nfs_server=>"none", :consoleport=>443}
+      end
+
+      it "can merge CONFIG section into overall hash" do
+        FakeFS.deactivate!
+        config = parser.parse_hosts_file(filepath)
+        expect(config['CONFIG']).to be === nil
+        expect(config['consoleport']).to be === 443
+      end
+
+      it "raises an error on no file found" do
+        FakeFS.deactivate!
+        expect{parser.parse_hosts_file("not a valid path")}.to raise_error(ArgumentError)
+      end
+
+    end
+  end
+end

data/spec/beaker/options/options_file_parser_spec.rb

@@ -0,0 +1,23 @@
+require "spec_helper"
+
+module Beaker
+  module Options
+    describe OptionsFileParser do
+
+      let(:parser) {Beaker::Options::OptionsFileParser}
+      let(:simple_opts) {File.join(File.expand_path(File.dirname(__FILE__)), "data", "opts.txt")}
+
+      it "can correctly read options from a file" do
+        FakeFS.deactivate!
+        expect(parser.parse_options_file(simple_opts)).to be === {:debug=>true, :tests=>"test.rb", :pre_suite=>["pre-suite.rb"], :post_suite=>"post_suite1.rb,post_suite2.rb"}
+      end
+
+      it "raises an error on no file found" do
+        FakeFS.deactivate!
+        expect{parser.parse_options_file("not a valid path")}.to raise_error(ArgumentError)
+      end
+
+
+    end
+  end
+end

data/spec/beaker/options/options_hash_spec.rb

@@ -0,0 +1,111 @@
+require "spec_helper"
+
+module Beaker
+  module Options
+    describe OptionsHash do
+      let(:options)    { Beaker::Options::OptionsHash.new }
+
+      #test options hash methods
+      it "converts all string keys to symbols when doing direct assignment" do
+        options['key'] = 'value'
+        expect(options.has_key?(:key)) === true  and expect(options.has_key?('key')) === false
+      end
+
+      it "can look up by string or symbol key" do
+        options.merge({'key' => 'value'})
+        expect(options['key']) === 'value' and expect(options[:key]) === 'value'
+      end
+
+      it "supports is_pe?, defaults to pe" do
+        expect(options.is_pe?) === true
+      end
+
+      it "supports is_pe?, respects :type == foss" do
+        options[:type] = 'foss'
+        expect(options.is_pe?) === false
+      end
+
+      it "can delete by string of symbol key" do
+        options['key'] = 'value'
+        expect(options.delete('key')) === 'value' and expect(options.delete(:key)) === 'value'
+      end
+
+      it "when merged with a Hash remains an OptionsHash" do
+        options.merge({'key' => 'value'})
+        expect(options.is_a?(OptionsHash)) === true
+      end
+
+      it "when merged with a hash that contains a hash, the sub-hash becomes an OptionsHash" do
+        options.merge({'key' => {'subkey' => 'subvalue'}})
+        expect(options[:key].is_a?(OptionsHash)) === true and expect(options[:key][:subkey]) === 'subvalue'
+      end
+
+      context 'pretty prints itself' do
+
+        it 'in valid JSON' do
+          require 'json'
+
+          options['array'] = ['one', 'two', 'three']
+          options['hash'] = {'subkey' => { 'subsub' => 1 }}
+          options['nil'] = nil
+          options['number'] = 4
+          options['float'] = 1.0
+          options['string'] = 'string'
+          options['true'] = true
+
+          expect{ JSON.parse( options.dump ) }.to_not raise_error
+        end
+
+        context 'for non collection values shows' do
+          it 'non-string like values as bare words' do
+            expect( options.fmt_value( 4 ) ).to be == "4"
+            expect( options.fmt_value( 1.0 ) ).to be == "1.0"
+            expect( options.fmt_value( true ) ).to be == "true"
+            expect( options.fmt_value( false ) ).to be == "false"
+          end
+
+          it 'nil values as null' do
+            expect( options.fmt_value( nil ) ).to be == 'null'
+          end
+
+          it 'strings within double quotes' do
+            expect( options.fmt_value( 'thing' ) ).to be == '"thing"'
+          end
+        end
+
+        context 'for list like collections shows' do
+          it 'each element on a new line' do
+            fmt_list = options.fmt_value( %w{ one two three } )
+
+            expect( fmt_list ).to match(/^\s*"one",?$/)
+            expect( fmt_list ).to match(/^\s*"two",?$/)
+            expect( fmt_list ).to match(/^\s*"three",?$/)
+          end
+
+          it 'square brackets on either end of the list' do
+            fmt_list = options.fmt_value( %w{ one two three } )
+
+            expect( fmt_list ).to match( /\A\[\s*$/ )
+            expect( fmt_list ).to match( /^\s*\]\Z/ )
+          end
+        end
+
+        context 'for dict like collections shows' do
+          it 'each element on a new line' do
+            fmt_assoc = options.fmt_value( {:one => 'two', :two => 'three'} )
+
+            expect( fmt_assoc ).to match(/^\s*"one": "two",?$/)
+            expect( fmt_assoc ).to match(/^\s*"two": "three",?$/)
+          end
+
+          it 'curly braces on either end of the list' do
+            fmt_assoc = options.fmt_value( {:one => 'two', :two => 'three'} )
+
+            expect( fmt_assoc ).to match( /\A\{\s*$/ )
+            expect( fmt_assoc ).to match( /^\s*\}\Z/ )
+          end
+        end
+      end
+    end
+  end
+end