beaker 2.44.0 → 2.45.0

data/spec/beaker/dsl/install_utils/windows_utils_spec.rb

@@ -42,11 +42,11 @@ describe ClassMixedWithDSLInstallUtils do
 
   def expect_version_log_called(times = hosts.length)
     [
-      "\"%ProgramFiles%\\Puppet Labs\\puppet\\misc\\versions.txt\"",
-      "\"%ProgramFiles(x86)%\\Puppet Labs\\puppet\\misc\\versions.txt\"",
+      "\\\"%ProgramFiles%\\Puppet Labs\\puppet\\misc\\versions.txt\\\"",
+      "\\\"%ProgramFiles(x86)%\\Puppet Labs\\puppet\\misc\\versions.txt\\\"",
     ].each do |path|
       expect( Beaker::Command ).to receive( :new )
-        .with( "if exist #{path} type #{path}", [], {:cmdexe => true} )
+        .with( "\"if exist #{path} type #{path}\"", [], {:cmdexe => true} )
         .exactly( times ).times
     end
   end

data/spec/beaker/host/unix/pkg_spec.rb

@@ -243,6 +243,26 @@ module Beaker
           expect( instance ).to receive(:exec).with('', {}).and_return(generate_result("hello", {:exit_code => 0}))
           expect(instance.uninstall_package('pkg')).to be == "hello"
         end
+
+        (1..21).to_a.each do | fedora_release |
+          it "uses yum on fedora-#{fedora_release}" do
+            @opts = {'platform' => "fedora-#{fedora_release}-is-me"}
+            pkg = 'fedora_package'
+            expect( Beaker::Command ).to receive(:new).with("yum -y  remove #{pkg}", [], {:prepend_cmds=>nil, :cmdexe=>false}).and_return('')
+            expect( instance ).to receive(:exec).with('', {}).and_return(generate_result("hello", {:exit_code => 0}))
+            expect( instance.uninstall_package(pkg) ).to be == "hello"
+          end
+        end
+
+        (22..29).to_a.each do | fedora_release |
+          it "uses dnf on fedora-#{fedora_release}" do
+            @opts = {'platform' => "fedora-#{fedora_release}-is-me"}
+            pkg = 'fedora_package'
+            expect( Beaker::Command ).to receive(:new).with("dnf -y  remove #{pkg}", [], {:prepend_cmds=>nil, :cmdexe=>false}).and_return('')
+            expect( instance ).to receive(:exec).with('', {}).and_return(generate_result("hello", {:exit_code => 0}))
+            expect( instance.uninstall_package(pkg) ).to be == "hello"
+          end
+        end
       end
     end
 

data/spec/beaker/host_prebuilt_steps_spec.rb

@@ -169,19 +169,19 @@ describe Beaker do
     it "can return the correct url for an el-7 host" do
       host = make_host( 'testhost', { :platform => Beaker::Platform.new('el-7-platform') } )
 
-      expect( subject.epel_info_for( host, options )).to be === ["http://mirrors.kernel.org/fedora-epel/7", "x86_64", "epel-release-7-6.noarch.rpm"]
+      expect( subject.epel_info_for( host, options )).to be === ["http://dl.fedoraproject.org/pub/epel/7", "x86_64", "epel-release-7-7.noarch.rpm"]
     end
 
     it "can return the correct url for an el-6 host" do
       host = make_host( 'testhost', { :platform => Beaker::Platform.new('el-6-platform') } )
 
-      expect( subject.epel_info_for( host, options )).to be === ["http://mirrors.kernel.org/fedora-epel/6", "i386", "epel-release-6-8.noarch.rpm"]
+      expect( subject.epel_info_for( host, options )).to be === ["http://dl.fedoraproject.org/pub/epel/6", "i386", "epel-release-6-8.noarch.rpm"]
     end
 
     it "can return the correct url for an el-5 host" do
       host = make_host( 'testhost', { :platform => Beaker::Platform.new('el-5-platform') } )
 
-      expect( subject.epel_info_for( host, options )).to be === ["http://mirrors.kernel.org/fedora-epel/5", "i386", "epel-release-5-4.noarch.rpm"]
+      expect( subject.epel_info_for( host, options )).to be === ["http://dl.fedoraproject.org/pub/epel/5", "i386", "epel-release-5-4.noarch.rpm"]
 
     end
 
@@ -335,10 +335,10 @@ describe Beaker do
       hosts[4][:platform] = Beaker::Platform.new('oracle-5-arch')
 
       expect( Beaker::Command ).to receive( :new ).with("rpm -qa | grep epel-release").exactly( 6 ).times
-      expect( Beaker::Command ).to receive( :new ).with("rpm -i http://mirrors.kernel.org/fedora-epel/6/i386/epel-release-6-8.noarch.rpm").exactly( 4 ).times
-      expect( Beaker::Command ).to receive( :new ).with("rpm -i http://mirrors.kernel.org/fedora-epel/5/i386/epel-release-5-4.noarch.rpm").exactly( 2 ).times
-      expect( Beaker::Command ).to receive( :new ).with("sed -i -e 's;#baseurl.*$;baseurl=http://mirrors\\.kernel\\.org/fedora\\-epel/6/$basearch;' /etc/yum.repos.d/epel.repo").exactly( 4 ).times
-      expect( Beaker::Command ).to receive( :new ).with("sed -i -e 's;#baseurl.*$;baseurl=http://mirrors\\.kernel\\.org/fedora\\-epel/5/$basearch;' /etc/yum.repos.d/epel.repo").exactly( 2 ).times
+      expect( Beaker::Command ).to receive( :new ).with("rpm -i http://dl.fedoraproject.org/pub/epel/6/i386/epel-release-6-8.noarch.rpm").exactly( 4 ).times
+      expect( Beaker::Command ).to receive( :new ).with("rpm -i http://dl.fedoraproject.org/pub/epel/5/i386/epel-release-5-4.noarch.rpm").exactly( 2 ).times
+      expect( Beaker::Command ).to receive( :new ).with("sed -i -e 's;#baseurl.*$;baseurl=http://dl\\.fedoraproject\\.org/pub/epel/6/$basearch;' /etc/yum.repos.d/epel.repo").exactly( 4 ).times
+      expect( Beaker::Command ).to receive( :new ).with("sed -i -e 's;#baseurl.*$;baseurl=http://dl\\.fedoraproject\\.org/pub/epel/5/$basearch;' /etc/yum.repos.d/epel.repo").exactly( 2 ).times
       expect( Beaker::Command ).to receive( :new ).with("sed -i -e '/mirrorlist/d' /etc/yum.repos.d/epel.repo").exactly( 6 ).times
       expect( Beaker::Command ).to receive( :new ).with("yum clean all && yum makecache").exactly( 6 ).times
 

data/spec/beaker/host_spec.rb

@@ -696,5 +696,49 @@ module Beaker
       end
     end
 
+    describe '#get_public_ip' do
+      let (:aws) { double('AWSmock')}
+      it 'calls upon the ec2 instance to get the ip address' do
+        host.host_hash[:hypervisor] = 'ec2'
+        host.host_hash[:instance] = aws
+        expect(aws).to receive(:ip_address)
+        host.get_public_ip
+      end
+
+      it 'returns nil when no matching hypervisor is found' do
+        host.host_hash[:hypervisor] = 'vmpooler'
+        expect(host.get_public_ip).to be(nil)
+      end
+
+      it 'calls execute with curl if the host_hash[:instance] is not defined and the host is not an instance of Windows::Host' do
+        host.host_hash[:hypervisor] = 'ec2'
+        host.host_hash[:instance] = nil
+        expect(host).to receive(:instance_of?).with(Windows::Host).and_return(false)
+        expect(host).to receive(:execute).with("curl http://169.254.169.254/latest/meta-data/public-ipv4").and_return('127.0.0.1')
+        host.get_public_ip
+      end
+
+      it 'calls execute with wget if the host_hash[:instance] is not defined and the host is an instance of Windows::Host' do
+        host.host_hash[:hypervisor] = 'ec2'
+        host.host_hash[:instance] = nil
+        expect(host).to receive(:instance_of?).with(Windows::Host).and_return(true)
+        expect(host).to receive(:execute).with("wget http://169.254.169.254/latest/meta-data/public-ipv4").and_return('127.0.0.1')
+        host.get_public_ip
+      end
+    end
+
+    describe '#ip' do
+      it 'calls #get_ip when get_public_ip returns nil' do
+        allow( host ).to receive(:get_public_ip).and_return(nil)
+        expect(host).to receive(:get_ip).and_return('127.0.0.2')
+        expect(host.ip).to eq('127.0.0.2')
+      end
+
+      it 'does not call get_ip when #get_public_ip returns an address' do
+        allow( host ).to receive(:get_public_ip).and_return('127.0.0.1')
+        expect(host).to_not receive(:get_ip)
+        expect(host.ip).to eq('127.0.0.1')
+      end
+    end
   end
 end

data/spec/beaker/hypervisor/openstack_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+require 'fog'
+
+module Beaker
+  describe OpenStack do
+
+    let(:options) { make_opts.merge({'logger' => double().as_null_object}) }
+
+    let(:openstack) {
+      OpenStack.new(@hosts, options)
+    }
+
+    before :each do
+      @hosts = make_hosts()
+
+      @compute_client = double().as_null_object
+      @network_client = double().as_null_object
+
+      allow( Fog::Compute ).to receive( :new ).and_return( @compute_client )
+      allow( Fog::Network ).to receive( :new ).and_return( @network_client )
+    end
+
+    it 'check openstack options during initialization' do
+      options = openstack.instance_eval('@options')
+      expect(options['openstack_api_key']).to eq('P1as$w0rd')
+      expect(options['openstack_username']).to eq('user')
+      expect(options['openstack_auth_url']).to eq('http://openstack_hypervisor.labs.net:5000/v2.0/tokens')
+      expect(options['openstack_tenant']).to eq('testing')
+      expect(options['openstack_network']).to eq('testing')
+      expect(options['openstack_keyname']).to eq('nopass')
+    end
+
+    it 'check hosts options during initialization' do
+      hosts = openstack.instance_eval('@hosts')
+      @hosts.each do |host|
+        expect(host['image']).to eq('default_image')
+        expect(host['flavor']).to eq('m1.large')
+        expect(host['user_data']).to eq('#cloud-config\nmanage_etc_hosts: true\nfinal_message: "The host is finally up!"')
+      end
+    end
+
+    it 'check host options during server creation' do
+
+      mock_flavor = Object.new
+      allow( mock_flavor ).to receive( :id ).and_return( 12345 )
+      allow( openstack ).to receive( :flavor ).and_return( mock_flavor )
+      expect( openstack ).to receive( :flavor ).with( 'm1.large' )
+
+      mock_image = Object.new
+      allow( mock_image ).to receive( :id ).and_return( 54321 )
+      allow( openstack ).to receive( :image ).and_return( mock_image )
+      expect( openstack ).to receive( :image ).with( 'default_image' )
+
+      mock_servers = double().as_null_object
+      allow( @compute_client ).to receive( :servers ).and_return( mock_servers )
+      expect(mock_servers).to receive(:create).with(hash_including(
+        :user_data => '#cloud-config\nmanage_etc_hosts: true\nfinal_message: "The host is finally up!"',
+        :flavor_ref => 12345,
+        :image_ref => 54321)
+      )
+
+      openstack.provision
+    end
+
+  end
+end

data/spec/beaker/hypervisor/vagrant_spec.rb

@@ -18,6 +18,11 @@ module Beaker
         :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
@@ -49,6 +54,9 @@ Vagrant.configure("2") do |c|
     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
@@ -61,6 +69,9 @@ Vagrant.configure("2") do |c|
     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
@@ -73,6 +84,9 @@ Vagrant.configure("2") do |c|
     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
@@ -152,6 +166,91 @@ EOF
   
     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|

data/spec/beaker/options/hosts_file_parser_spec.rb

@@ -7,36 +7,109 @@ module Beaker
       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
+      describe '#parse_hosts_file' do
+        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 "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 "returns empty configuration when no file provided" do
+          FakeFS.deactivate!
+          expect(parser.parse_hosts_file()).to be === { :HOSTS => {} }
+        end
+
+        it "raises an error on no file found" do
+          FakeFS.deactivate!
+          expect{parser.parse_hosts_file("not a valid path")}.to raise_error(Errno::ENOENT)
+        end
 
-      it "returns empty configuration when no file provided" do
-        FakeFS.deactivate!
-        expect(parser.parse_hosts_file()).to be === { :HOSTS => {} }
+        it "raises an error on bad yaml file" do
+          FakeFS.deactivate!
+          allow( YAML ).to receive(:load_file) { raise Psych::SyntaxError }
+          allow( File ).to receive(:exists?).and_return(true)
+          expect { parser.parse_hosts_file("not a valid path") }.to raise_error(ArgumentError)
+        end
+
+        it 'returns a #new_host_options hash if given no arguments' do
+          host_options = parser.parse_hosts_file
+          expect( host_options ).to be === parser.new_host_options
+        end
+
+        it 'passes a YAML.load_file call through to #merge_hosts_yaml' do
+          yaml_string = 'not actually yaml, but that wont matter'
+          allow( File ).to receive( :expand_path ).with( yaml_string ) { yaml_string }
+          expect( YAML ).to receive( :load_file ).with( yaml_string )
+          parser.parse_hosts_file( yaml_string )
+        end
       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)
+      describe '#parse_hosts_string' do
+
+        it 'will return a #new_host_options hash if given no arguments' do
+          host_options = parser.parse_hosts_string
+          expect( host_options ).to be === parser.new_host_options
+        end
+
+        it 'passes a YAML.load call through to #merge_hosts_yaml' do
+          yaml_string = 'not actually yaml, but that wont matter'
+          expect( YAML ).to receive( :load ).with( yaml_string )
+          parser.parse_hosts_string( yaml_string )
+        end
       end
 
-      it "raises an error on bad yaml file" do
-        FakeFS.deactivate!
-        allow( YAML ).to receive(:load_file) { raise Psych::SyntaxError }
-        allow( File ).to receive(:exists?).and_return(true)
-        expect { parser.parse_hosts_file("not a valid path") }.to raise_error(ArgumentError)
+      describe '#merge_hosts_yaml' do
+        it 'merges yielded block result with host_options argument & returns it' do
+          host_options = {}
+          yield_to_merge = { :pants => 'truth to the face' }
+          block_count = 0
+          answer = parser.merge_hosts_yaml( host_options, 'err_msg' ) {
+            block_count += 1
+            yield_to_merge
+          }
+
+          expect( block_count ).to be === 1
+          expect( answer ).to be === host_options.merge( yield_to_merge )
+        end
+
+        class MockSyntaxError < Psych::SyntaxError
+          def initialize
+            super( '', 0, 0, 0, '', '' )
+          end
+        end
+
+        it 'raises an ArgumentError if can\'t process YAML' do
+          # allow( parser ).to receive( :merge_hosts_yaml )
+          err_value = 'err_msg8797'
+          expect {
+            parser.merge_hosts_yaml( {}, err_value ) {
+              raise MockSyntaxError
+            }
+          }.to raise_error( ArgumentError, /#{err_value}/ )
+        end
       end
 
+      describe '#fix_roles_array' do
+        it 'adds a roles array to a host if not present' do
+          host_options = { 'HOSTS' => {
+            'host1' => {},
+            'host2' => {}
+          }}
+
+          parser.fix_roles_array( host_options )
+
+          host_options['HOSTS'].each do |host_name, host_hash|
+            expect( host_hash['roles'] ).to be === []
+          end
+        end
+      end
     end
   end
 end