beaker 1.21.0 → 2.0.0

data/spec/beaker/hypervisor/aws_sdk_spec.rb

@@ -2,13 +2,14 @@ require 'spec_helper'
 
 module Beaker
   describe AwsSdk do
+    let( :options ) { make_opts.merge({ 'logger' => double().as_null_object }) }
     let(:aws) {
       # Mock out the call to load_fog_credentials
-      Beaker::AwsSdk.any_instance.stub(:load_fog_credentials).and_return(fog_file_contents)
+      allow_any_instance_of( Beaker::AwsSdk ).to receive(:load_fog_credentials).and_return(fog_file_contents)
 
       # This is needed because the EC2 api looks up a local endpoints.json file
       FakeFS.deactivate!
-      aws = Beaker::AwsSdk.new(@hosts, make_opts)
+      aws = Beaker::AwsSdk.new(@hosts, options)
       FakeFS.activate!
 
       aws
@@ -26,18 +27,32 @@ module Beaker
         :image => {:pe => "ami-sekrit3"},
         :region => "us-west-2",
       },
+      "ubuntu-12.04-amd64-west" => {
+        :image => {:pe => "ami-sekrit4"},
+        :region => "us-west-2"
+      },
     }}
 
     before :each do
-      @hosts = make_hosts({:snapshot => :pe})
+      @hosts = make_hosts({:snapshot => :pe}, 4)
       @hosts[0][:platform] = "centos-5-x86-64-west"
       @hosts[1][:platform] = "centos-6-x86-64-west"
       @hosts[2][:platform] = "centos-7-x86-64-west"
+      @hosts[3][:platform] = "ubuntu-12.04-amd64-west"
+      @hosts[3][:user] = "ubuntu"
+    end
+
+    context 'enabling root shall be called once for the ubuntu machine' do
+      it "should enable root once" do
+        expect( aws ).to receive(:copy_ssh_to_root).with( @hosts[3], options ).once()
+        expect( aws ).to receive(:enable_root_login).with( @hosts[3], options).once()
+        aws.enable_root_on_hosts();
+      end
     end
 
     context '#backoff_sleep' do
       it "should call sleep 1024 times at attempt 10" do
-        Object.any_instance.should_receive(:sleep).with(1024)
+        expect_any_instance_of( Object ).to receive(:sleep).with(1024)
         aws.backoff_sleep(10)
       end
     end
@@ -48,7 +63,7 @@ module Beaker
         allow(File).to receive(:exists?).with(/id_rsa.pub/) { true }
         allow(File).to receive(:read).with(/id_rsa.pub/) { "foobar" }
 
-        # Should return contents of previously stubbed id_rsa.pub
+        # Should return contents of allow( previously ).to receivebed id_rsa.pub
         expect(aws.public_key).to eq("foobar")
       end
 
@@ -60,8 +75,8 @@ module Beaker
     context '#key_name' do
       it 'returns a key name from the local hostname' do
         # Mock out the hostname and local user calls
-        Socket.should_receive(:gethostname) { "foobar" }
-        aws.should_receive(:local_user) { "bob" }
+        expect( Socket ).to receive(:gethostname) { "foobar" }
+        expect( aws ).to receive(:local_user) { "bob" }
 
         # Should match the expected composite key name
         expect(aws.key_name).to eq("Beaker-bob-foobar")

data/spec/beaker/hypervisor/docker_spec.rb

@@ -14,27 +14,27 @@ module Beaker
 
     let(:logger) do
       logger = double('logger')
-      logger.stub(:debug)
-      logger.stub(:info)
-      logger.stub(:warn)
-      logger.stub(:error)
-      logger.stub(:notify)
+      allow( logger ).to receive(:debug)
+      allow( logger ).to receive(:info)
+      allow( logger ).to receive(:warn)
+      allow( logger ).to receive(:error)
+      allow( logger ).to receive(:notify)
       logger
     end
 
     let(:image) do
       image = double('Docker::Image')
-      image.stub(:id)
-      image.stub(:tag)
-      image.stub(:delete)
+      allow( image ).to receive(:id)
+      allow( image ).to receive(:tag)
+      allow( image ).to receive(:delete)
       image
     end
 
     let(:container) do
       container = double('Docker::Container')
-      container.stub(:id)
-      container.stub(:start)
-      container.stub(:json).and_return({
+      allow( container ).to receive(:id)
+      allow( container ).to receive(:start)
+      allow( container ).to receive(:json).and_return({
         'NetworkSettings' => {
           'IPAddress' => '192.0.2.1',
           'Ports' => {
@@ -47,51 +47,63 @@ module Beaker
           },
         },
       })
-      container.stub(:stop)
-      container.stub(:delete)
+      allow( container ).to receive(:stop)
+      allow( container ).to receive(:delete)
       container
     end
 
     let (:docker) { ::Beaker::Docker.new( hosts, { :logger => logger }) }
+    let(:docker_options) { nil }
 
     before :each do
       # Stub out all of the docker-api gem. we should never really call it
       # from these tests
-      ::Beaker::Docker.any_instance.stub(:require).with('docker')
-      ::Docker.stub(:options=)
-      ::Docker.stub(:logger=)
-      ::Docker.stub(:validate_version!)
-      ::Docker::Image.stub(:build).and_return(image)
-      ::Docker::Container.stub(:create).and_return(container)
-      ::Docker::Container.any_instance.stub(:start)
+      allow_any_instance_of( ::Beaker::Docker ).to receive(:require).with('docker')
+      allow( ::Docker ).to receive(:options).and_return(docker_options)
+      allow( ::Docker ).to receive(:options=)
+      allow( ::Docker ).to receive(:logger=)
+      allow( ::Docker ).to receive(:validate_version!)
+      allow( ::Docker::Image ).to receive(:build).and_return(image)
+      allow( ::Docker::Container ).to receive(:create).and_return(container)
+      allow_any_instance_of( ::Docker::Container ).to receive(:start)
     end
 
     describe '#initialize' do
       it 'should require the docker gem' do
-        ::Beaker::Docker.any_instance.should_receive(:require).with('docker').once
+        expect_any_instance_of( ::Beaker::Docker ).to receive(:require).with('docker').once
 
         docker
       end
 
       it 'should fail when the gem is absent' do
-        ::Beaker::Docker.any_instance.stub(:require).with('docker').and_raise(LoadError)
+        allow_any_instance_of( ::Beaker::Docker ).to receive(:require).with('docker').and_raise(LoadError)
         expect { docker }.to raise_error(LoadError)
       end
 
       it 'should set Docker options' do
-        ::Docker.should_receive(:options=).once
+        expect( ::Docker ).to receive(:options=).with({:write_timeout => 300, :read_timeout => 300}).once
 
         docker
       end
 
+      context 'when Docker options are already set' do
+        let(:docker_options) {{:write_timeout => 600, :foo => :bar}}
+
+        it 'should not override Docker options' do
+          expect( ::Docker ).to receive(:options=).with({:write_timeout => 600, :read_timeout => 300, :foo => :bar}).once
+
+          docker
+        end
+      end
+
       it 'should check the Docker gem can work with the api' do
-        ::Docker.should_receive(:validate_version!).once
+        expect( ::Docker ).to receive(:validate_version!).once
 
         docker
       end
 
       it 'should hook the Beaker logger into the Docker one' do
-        ::Docker.should_receive(:logger=).with(logger)
+        expect( ::Docker ).to receive(:logger=).with(logger)
 
         docker
       end
@@ -99,27 +111,27 @@ module Beaker
 
     describe '#provision' do
       before :each do
-        docker.stub(:dockerfile_for)
+        allow( docker ).to receive(:dockerfile_for)
       end
 
       it 'should call dockerfile_for with all the hosts' do
         hosts.each do |host|
-          docker.should_receive(:dockerfile_for).with(host).and_return('')
+          expect( docker ).to receive(:dockerfile_for).with(host).and_return('')
         end
 
         docker.provision
       end
 
       it 'should pass the Dockerfile on to Docker::Image.create' do
-        docker.stub(:dockerfile_for).and_return('special testing value')
-        ::Docker::Image.should_receive(:build).with('special testing value', { :rm => true })
+        allow( docker ).to receive(:dockerfile_for).and_return('special testing value')
+        expect( ::Docker::Image ).to receive(:build).with('special testing value', { :rm => true })
 
         docker.provision
       end
 
       it 'should create a container based on the Image (identified by image.id)' do
         hosts.each do |host|
-          ::Docker::Container.should_receive(:create).with({
+          expect( ::Docker::Container ).to receive(:create).with({
             'Image' => image.id,
             'Hostname' => host.name,
           })
@@ -129,7 +141,7 @@ module Beaker
       end
 
       it 'should start the container' do
-        container.should_receive(:start).with({'PublishAllPorts' => true, 'Privileged' => true})
+        expect( container ).to receive(:start).with({'PublishAllPorts' => true, 'Privileged' => true})
 
         docker.provision
       end
@@ -142,67 +154,67 @@ module Beaker
           ENV['DOCKER_HOST'] = nil
           docker.provision
 
-          hosts[0]['ip'].should == '127.0.1.1'
-          hosts[0]['port'].should == 8022
+          expect( hosts[0]['ip'] ).to be === '127.0.1.1'
+          expect( hosts[0]['port'] ).to be ===  8022
         end
 
         it 'should expose port 22 to beaker when using DOCKER_HOST' do
           ENV['DOCKER_HOST'] = "tcp://192.0.2.2:2375"
           docker.provision
 
-          hosts[0]['ip'].should == '192.0.2.2'
-          hosts[0]['port'].should == 8022
+          expect( hosts[0]['ip'] ).to be === '192.0.2.2'
+          expect( hosts[0]['port'] ).to be === 8022
         end
       end
 
       it 'should record the image and container for later' do
         docker.provision
 
-        hosts[0]['docker_image'].should == image
-        hosts[0]['docker_container'].should == container
+        expect( hosts[0]['docker_image'] ).to be === image
+        expect( hosts[0]['docker_container'] ).to be === container
       end
     end
 
     describe '#cleanup' do
       before :each do
         # get into a state where there's something to clean
-        docker.stub(:dockerfile_for)
+        allow( docker ).to receive(:dockerfile_for)
         docker.provision
       end
 
       it 'should stop the containers' do
-        docker.stub( :sleep ).and_return(true)
-        container.should_receive(:stop)
+        allow( docker ).to receive( :sleep ).and_return(true)
+        expect( container ).to receive(:stop)
         docker.cleanup
       end
 
       it 'should delete the containers' do
-        docker.stub( :sleep ).and_return(true)
-        container.should_receive(:delete)
+        allow( docker ).to receive( :sleep ).and_return(true)
+        expect( container ).to receive(:delete)
         docker.cleanup
       end
 
       it 'should delete the images' do
-        docker.stub( :sleep ).and_return(true)
-        image.should_receive(:delete)
+        allow( docker ).to receive( :sleep ).and_return(true)
+        expect( image ).to receive(:delete)
         docker.cleanup
       end
 
       it 'should not delete the image if docker_preserve_image is set to true' do
-        docker.stub( :sleep ).and_return(true)
+        allow( docker ).to receive( :sleep ).and_return(true)
         hosts.each do |host|
           host['docker_preserve_image']=true
         end
-        image.should_not_receive(:delete)
+        expect( image ).to_not receive(:delete)
         docker.cleanup
       end
 
       it 'should delete the image if docker_preserve_image is set to false' do
-        docker.stub( :sleep ).and_return(true)
+        allow( docker ).to receive( :sleep ).and_return(true)
         hosts.each do |host|
           host['docker_preserve_image']=false
         end
-        image.should_receive(:delete)
+        expect( image ).to receive(:delete)
         docker.cleanup
       end
 
@@ -223,7 +235,16 @@ module Beaker
           ]
         })
 
-        dockerfile.should =~ /RUN special one\nRUN special two\nRUN special three/
+        expect( dockerfile ).to be =~ /RUN special one\nRUN special two\nRUN special three/
+      end
+
+      it 'should add docker_image_entrypoint' do
+        dockerfile = docker.send(:dockerfile_for, {
+          'platform' => 'el-',
+          'docker_image_entrypoint' => '/bin/bash'
+        })
+
+        expect( dockerfile ).to be =~ %r{ENTRYPOINT /bin/bash}
       end
 
       it 'should use zypper on sles' do
@@ -231,7 +252,7 @@ module Beaker
           'platform' => 'sles',
         })
 
-        dockerfile.should =~ /RUN zypper -n in openssh/
+        expect( dockerfile ).to be =~ /RUN zypper -n in openssh/
       end
     end
   end

data/spec/beaker/hypervisor/ec2_helper_spec.rb

@@ -4,20 +4,41 @@ require 'beaker/hypervisor/ec2_helper'
 describe Beaker::EC2Helper do
   context ".amiports" do
     let(:ec2) { Beaker::EC2Helper }
+
+    let(:master_host)  do
+      opts = { :snapshot => :pe, :roles => ['master'], :additional_ports => 9999 }
+      make_host('master', opts)
+    end
+
+    let(:database_host)  do
+      opts = { :snapshot => :pe, :roles => ['database'], :additional_ports => [1111, 5432] }
+      make_host('database', opts)
+    end
+
+    let(:dashboard_host)  do
+      opts = { :snapshot => :pe, :roles => ['dashboard'], :additional_ports => 2003 }
+      make_host('dashboard', opts)
+    end
+
+    let(:all_in_one_host)  do
+      opts = { :snapshot => :pe, :roles => ['master', 'database', 'dashboard']}
+      make_host('all_in_one', opts)
+    end
+
     it "can set ports for database host" do
-      expect(ec2.amiports(["database"])).to be === [22, 61613, 8139, 8080, 8081]
+      expect(ec2.amiports(database_host)).to be === [22, 61613, 8139, 5432, 8080, 8081, 1111]
     end
 
     it "can set ports for master host" do
-      expect(ec2.amiports(["master"])).to be === [22, 61613, 8139, 8140]
+      expect(ec2.amiports(master_host)).to be === [22, 61613, 8139, 8140, 9999]
     end
 
     it "can set ports for dashboard host" do
-      expect(ec2.amiports(["dashboard"])).to be === [22, 61613, 8139, 443, 4435]
+      expect(ec2.amiports(dashboard_host)).to be === [22, 61613, 8139, 443, 4433, 4435, 2003]
     end
 
     it "can set ports for combined master/database/dashboard host" do
-      expect(ec2.amiports(["dashboard", "master", "database"])).to be === [22, 61613, 8139, 8080, 8081, 8140, 443, 4435]
+      expect(ec2.amiports(all_in_one_host)).to be === [22, 61613, 8139, 5432, 8080, 8081, 8140, 443, 4433, 4435]
     end
   end
 end

data/spec/beaker/hypervisor/fusion_spec.rb

@@ -5,10 +5,10 @@ module Beaker
     let( :fusion ) { Beaker::Fusion.new( @hosts, make_opts ) }
 
     before :each do
-      stub_const( "Fission::VM", true )
+     stub_const( "Fission::VM", true )
       @hosts = make_hosts()
       MockFission.presets( @hosts )
-      Fusion.any_instance.stub( :require ).with( 'fission' ).and_return( true )
+      allow_any_instance_of( Fusion ).to receive( :require ).with( 'fission' ).and_return( true )
       fusion.instance_variable_set( :@fission, MockFission ) 
     end
 

data/spec/beaker/hypervisor/hypervisor_spec.rb

@@ -6,75 +6,68 @@ module Beaker
 
     it "creates an aix hypervisor for aix hosts" do
       aix = double( 'aix' )
-      aix.stub( :provision ).and_return( true )
+      allow( aix ).to receive( :provision ).and_return( true )
 
-      Aixer.should_receive( :new ).once.and_return( aix )
+      expect( Aixer ).to 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 )
+      allow( solaris ).to receive( :provision ).and_return( true )
+      expect( Solaris ).to 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 )
+      allow( vsphere ).to receive( :provision ).and_return( true )
+      expect( Vsphere ).to 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 )
+      allow( fusion ).to receive( :provision ).and_return( true )
+      expect( Fusion ).to 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 )
+      allow( vcloud ).to receive( :provision ).and_return( true )
+      expect( VcloudPooled ).to 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 )
+      allow( vcloud ).to receive( :provision ).and_return( true )
+      expect( Vcloud ).to 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 )
+      allow( vagrant ).to receive( :provision ).and_return( true )
+      expect( Vagrant ).to 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 )
+      allow( vagrant ).to receive( :provision ).and_return( true )
+      expect( VagrantFusion ).to 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 )
+      allow( vagrant ).to receive( :provision ).and_return( true )
+      expect( VagrantVirtualbox ).to 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
-
     context "#configure" do
       let( :options ) { make_opts.merge({ 'logger' => double().as_null_object }) }
       let( :hosts ) { make_hosts( { :platform => 'el-5' } ) }
@@ -83,7 +76,7 @@ module Beaker
       context "if :disable_iptables option set false" do
         it "does not call disable_iptables" do
           options[:disable_iptables] = false
-          hypervisor.should_receive( :disable_iptables ).never
+          expect( hypervisor ).to receive( :disable_iptables ).never
           hypervisor.configure
         end
       end
@@ -91,7 +84,7 @@ module Beaker
       context "if :disable_iptables option set true" do
         it "calls disable_iptables once" do
           options[:disable_iptables] = true
-          hypervisor.should_receive( :disable_iptables ).exactly( 1 ).times
+          expect( hypervisor ).to receive( :disable_iptables ).exactly( 1 ).times
           hypervisor.configure
         end
       end