beaker 3.15.0 → 3.16.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    NjRlOGQzYjVmMjI1MDFhYTQzZTRhNzZhOTM0Njg1MzI1ZGY1NmU4Nw==
+    MjFkMmNmNDJhOTkxZjJlYmViNDViMGE4N2NjNzllY2U3ZWY5MmVmNw==
   data.tar.gz: !binary |-
-    MzUxODYzYWY0ZWQ0YjM5OWU5ODQzNTY4OGFlOWU4YzlhYTQ3NzM2OQ==
+    MTI4OWYzMzQ2OGE2NmI3MDY4YzE1M2E2YTgyNzNlNTk1ZGI3ZDU3YQ==
 SHA512:
   metadata.gz: !binary |-
-    OTY1NmExNTVjODU2OGU1Zjg2Yjk4N2NmYmY2ODBjODNiYjIxZWExZjNjYzM2
-    NDJlNmIwYTcyNTIzOGU3YjUxMTJiODIyOGNjNGYzYTE5NDVlZDBlNzc2NjRj
-    Yjc5NGFkMzNiMDAxOTY2OGNlZWFiMGVhMTgyYjczMzM0YzljN2I=
+    NGY4Y2MwMzU0NzY0ZjgzNmJjYTk0OTZiNTcxODFlMDU2OTJhNTY2MmZkMDRj
+    NjA3MDRjMzJjY2QyOGE3NWY2YTVhNmU3ZDBhYjkwNjBkM2VjZTJiNjFkNDVj
+    YWU2NDEzOWQ5NzI2NTkxNTlhMTBlODNjYjc3YjJhODQ4YjhlM2E=
   data.tar.gz: !binary |-
-    N2QzYTg1NjZiOTAxYWY4YjQ3ODdiYjkyNjViN2Q5ZDg2OTA0MmNmMTRhNWVl
-    YTk1MTAwZTBmZTlhMzU2Mzk0NjU5OWUwZjU0YjYyODdjMmE4YWZhNDlmOGYz
-    MzczMjQ5YjVmZWIwMGJmN2RmYTcyNTE3ZjY0YjJlZTViNzY1ZDA=
+    MWRkNDY5MTM3OTFlZDcyMzQ3NjdmYjNmMDUzZWUyZTg1NjFjMDhmZmRjMzFh
+    ODZlZTM3OGMzY2YzMWVjOWZiNjk1YzA4NTQ3NGE2MTNjNjljNGMxMDgxYjNi
+    MTlhYTNjMDM1ZTFlOWFlNzk4NTQwNmViYmQyNDJhOTk4OWJkNmU=

data/docs/concepts/argument_processing_and_precedence.md

@@ -12,7 +12,7 @@ Beaker uses arguments and settings from a variety of sources to determine how yo
 
 
 ## Environment Variables
-###Supported Environment Variables:
+### Supported Environment Variables:
 ```
         BEAKER VARIABLE NAME  => ENVIRONMENT VARIABLE NAME
         :home                 => 'HOME',
@@ -81,7 +81,7 @@ $ beaker --debug --tests acceptance/tests/base/host.rb --hosts configs/fusion/wi
 ```
 `--debug`, `--tests acceptance/tests/base/host.rb` and `--hosts configs/fusion/winfusion.cfg` are the provided command line values for this test run.
 
-###Supported Command Line Arguments:
+### Supported Command Line Arguments:
 ```
 $ beaker --help
 Usage: beaker [options...]

data/docs/how_to/hypervisors/openstack.md

@@ -152,3 +152,15 @@ volume size in MB.
             size: 10000
           journal:
             size: 1000
+
+
+In the event you're using an OpenStack instance that does not deploy the volume service you can disable that functionality to prevent beaker runs from failing.  Either using an ENV variable or setting the following value in the `CONFIG` section of your hosts file(valid values are `true` or `false`):
+
+```
+openstack_volume_support: false
+```
+
+You can also configure this setting via an environment variable:
+
+```
+export OS_VOLUME_SUPPORT=false

data/docs/how_to/hypervisors/vmpooler.md

@@ -5,6 +5,10 @@ systems.
 beaker's vmpooler hypervisor interacts with vmpooler to get Systems Under Test
 (SUTs) for testing purposes.
 
+**Note** that if you're a puppet-internal user, you'll have to setup your SSH
+keys to communicate with vmpooler SUTs. To do that, refer to our
+[internal doc](https://confluence.puppetlabs.com/display/SRE/SSH+access+to+vmpooler+VMs).
+
 # Tokens
 
 Using tokens will allow you to extend your VMs lifetime, as well as interact

data/docs/how_to/hypervisors/vsphere.md

@@ -1,3 +1,11 @@
+This doc describes beaker's vSphere hypervisor. This is the interaction layer
+that beaker will use to get Systems Under Test (SUTs) from any vSphere
+infrastructure that you might have.
+
+**Note** that if you're a puppet-internal user, or an external user that is
+using the vmpooler hypervisor, please refer to our [vmpooler doc](vmpooler.md)
+for info, as it can be different than the information here. 
+
 The harness can use vms and snapshots that live within vSphere as well.
 To do this create a `~/.fog` file with your vSphere credentials:
 

data/docs/how_to/write_a_beaker_test_for_a_module.md

@@ -1,11 +1,11 @@
-#Beaker for Modules
-##Read the Beaker Docs
+# Beaker for Modules
+## Read the Beaker Docs
 
 [Beaker How To](../tutorials/how_to_beaker.md)
 [Beaker DSL API](http://rubydoc.info/github/puppetlabs/beaker/frames)
 
-##Understand the Difference Between beaker and beaker-rspec
+## Understand the Difference Between beaker and beaker-rspec
 [beaker vs. beaker-rspec](../concepts/beaker_vs_beaker_rspec.md)
 
-##beaker-rspec Details
+## beaker-rspec Details
 See the [beaker-rspec README](https://github.com/puppetlabs/beaker-rspec/blob/master/README.md) for details on how to use beaker-rspec with modules.

data/docs/tutorials/lets_write_a_test.md

@@ -1,8 +1,8 @@
-##The Task
+## The Task
 
 Consider if mcollectived incorrectly spawned a new process with every puppet agent run on Ubuntu 10.04.  We need an acceptance test to check that a new process is not spawned and to ensure that this issue does not regress in new builds.
 
-##Figure Out Test Steps
+## Figure Out Test Steps
 
 What needs to happen in this test:
 
@@ -10,10 +10,10 @@ What needs to happen in this test:
 * Restart mcollective twice
 * Check to see if more than one mcollective process is running
 
-##Create a host configuration file
+## Create a host configuration file
     $ beaker-hostgenerator redhat7-64ma > redhat7-64ma.yaml
 
-##Install PE
+## Install PE
 
 We prefer to install PE once and then run a set of tests, so PE installation should not be part of the actual acceptance test.
 
@@ -33,19 +33,19 @@ The install.rb script is used in our commandline to beaker, below.
 We need to create a test file to run.
 
 ### Define some test commands to run
-####Restart mcollective twice
+#### Restart mcollective twice
 
 Here's our magic command that restarts mcollective:
 
     restart_command = "bash -c '[[ -x /etc/init.d/pe-mcollective ]] && /etc/init.d/pe-mcollective restart'"
 
-####Check to see if more than one mcollective process is running
+#### Check to see if more than one mcollective process is running
 
 Here's our magic command that throws an error if more than one mcollective process is running:
 
     process_count_check = "bash -c '[[ $(ps auxww | grep [m]collectived | wc -l) -eq 1 ]]'"
 
-###Put it all together
+### Put it all together
 
 Here's the finished acceptance test.
 

data/docs/tutorials/quick_start_rake_tasks.md

@@ -1,4 +1,4 @@
-#Beaker Quick Start Tasks
+# Beaker Quick Start Tasks
 
 We have developed some rake tasks to help new Beaker users get up and running quickly with writing and running tests.
 
@@ -208,4 +208,4 @@ This task will run the above 3 tasks in sequential order and then execute a Beak
 
 You will end up with provisioned hosts with puppet installed and a test check executed to verify that puppet was installed.
 
-For more information on running Beaker tests see - [Test run](test_run.md)
+For more information on running Beaker tests see - [Test run](test_run.md)

data/docs/tutorials/subcommands.md

@@ -0,0 +1,54 @@
+# Using Subcommands
+
+The document gives an overview of the subcommands that beaker supports and
+describes a basic of how to use them.
+
+## Why Subcommands?
+
+Subcommands are designed to make test development and iteration simpler by
+separating out all of the phases of a beaker test run*. Instead of requiring the
+entirety of your beaker execution in one command, subcommands allow you to
+execute each phase independently. This allows for faster feedback for potential
+failures and better control for iterating over actual test development.
+
+Most subcommands pass through flags to the beaker options. For instance, you can
+pass through `--hosts` to the `init` subcommand and it will parse the `--hosts`
+argument as if you were executing a beaker run*. Please review the
+subcommand specific help for further information. You can see the help for a
+specific subcommand by running `beaker help SUBCOMMAND`.
+
+*Please note that in this document, a beaker `run` is standard beaker invocation
+without any subcommands.
+## Available Subcommands
+
+### beaker init
+Initializes the required `.beaker/` configuration folder. This folder contains a
+`subcommand_options.yaml` file that is user-facing; altering this file will
+alter the options for subcommand execution.
+
+### beaker provision
+Provisions hosts defined in your `subcommand_options file`. You can pass the
+`--hosts` flag here to override any hosts provided there.
+
+### beaker exec
+Run a single file, directory, or beaker suite. If supplied a file or directory,
+that resource will be run in the context of the `tests` suite; if supplied a
+beaker suite, then just that suite will run. If no resource is supplied, then
+this command executes the suites as they are defined in the configuration in the
+`subcommand_options.yaml`.
+
+### beaker destroy
+Execute this command to deprovision your systems under test(SUTs).
+
+## Basic workflow
+
+```
+beaker init -h hosts_file -o options_file --keyfile ssh_key --pre-suite ./setup/pre-suit/my_presuite.rb
+beaker provision
+# Note: do not pass in hosts file, or use the '-t' flag! Just the file
+# or directory. Do not pass GO. Do not collect $200.
+beaker exec ./tests/my_test.rb
+# Repeating the above command as needed
+# When you're done testing using the VM that beaker provisioned
+beaker destroy
+```

data/docs/tutorials/the_command_line.md

@@ -1,3 +1,4 @@
+# The Command Line
 * Using the gem
 
         $ beaker --log-level debug --hosts sample.cfg --tests test.rb
@@ -6,14 +7,14 @@
 
         $ bundle exec beaker --log-level debug --hosts sample.cfg --tests test.rb
 
-##Useful options
+## Useful options
 * `-h, --hosts FILE `, the hosts that you are going to be testing with
 * `--log-level debug`, for providing verbose logging and full stacktraces on failure
 * `--[no-]provision`, indicates if beaker should provision new boxes upon test execution. If `no` is selected then beaker will attempt to connect to the hosts as defined in `--hosts FILE` without first creating/running them through their hypervisors
 * `--preserve-hosts [MODE]`, indicates what should be done with the testing boxes after tests are complete.  If `always` is selected then the boxes will be preserved and left running post-testing.  If `onfail` is selected then the boxes will be preserved only if tests fail, otherwise they will be shut down and destroyed.  If `never` is selected then the boxes will be shut down and destroyed no matter the testing results.
 * `--parse-only`, read and parse all command line options, environment options and file options; report the parsed options and exit.
 
-##The Rest
+## The Rest
 See all options with
 * Using the gem
 

data/lib/beaker/host/cisco.rb

@@ -75,7 +75,7 @@ module Cisco
       end
 
       prepend_cmds = 'source /etc/profile;'
-      prepend_cmds << " sudo sh -c \"" if self[:user] != 'root'
+      prepend_cmds << " sudo -E sh -c \"" if self[:user] != 'root'
       if self[:vrf]
         prepend_cmds << "ip netns exec #{self[:vrf]} "
       end

data/lib/beaker/host/unix/pkg.rb

@@ -28,7 +28,14 @@ module Unix::Pkg
         result = execute("zypper se -i --match-exact #{name}", opts) { |result| result }
         result.stdout =~ /No packages found/ ? (return false) : (return result.exit_code == 0)
       when /sles-/
-        result = execute("zypper se -i --match-exact #{name}", opts) { |result| result }
+        if !self[:sles_rpmkeys_nightly_pl_imported]
+          # The `:sles_rpmkeys_nightly_pl_imported` key is only read here at this
+          # time. It's just to make sure that we only do the key import once, &
+          # isn't for setting or use outside of beaker.
+          execute('rpmkeys --import http://nightlies.puppetlabs.com/07BB6C57', opts)
+          self[:sles_rpmkeys_nightly_pl_imported] = true
+        end
+        result = execute("zypper --gpg-auto-import-keys se -i --match-exact #{name}", opts) { |result| result }
       when /el-4/
         @logger.debug("Package query not supported on rhel4")
         return false

data/lib/beaker/hypervisor/openstack.rb

@@ -63,6 +63,11 @@ module Beaker
         raise "Unable to create OpenStack Network instance (api_key: #{@options[:openstack_api_key]}, username: #{@options[:openstack_username]}, auth_url: #{@options[:openstack_auth_url]}, tenant: #{@options[:openstack_tenant]})"
       end
 
+      # Validate openstack_volume_support setting value, reset to boolean if passed via ENV value string
+      @options[:openstack_volume_support] = true  if @options[:openstack_volume_support].to_s.match(/\btrue\b/i)
+      @options[:openstack_volume_support] = false if @options[:openstack_volume_support].to_s.match(/\bfalse\b/i)
+      [true,false].include? @options[:openstack_volume_support] or raise "Invalid openstack_volume_support setting, current: @options[:openstack_volume_support]"
+
     end
 
     #Provided a flavor name return the OpenStack id for that flavor
@@ -229,7 +234,6 @@ module Beaker
         vm = @compute_client.servers.create(options)
 
         #wait for the new instance to start up
-        start = Time.now
         try = 1
         attempts = @options[:timeout].to_i / SLEEPWAIT
 
@@ -266,7 +270,8 @@ module Beaker
         #enable root if user is not root
         enable_root(host)
 
-        provision_storage(host, vm)
+        provision_storage(host, vm) if @options[:openstack_volume_support]
+        @logger.notify "OpenStack Volume Support Disabled, can't provision volumes" if not @options[:openstack_volume_support]
       end
 
       hack_etc_hosts @hosts, @options
@@ -277,7 +282,7 @@ module Beaker
     def cleanup
       @logger.notify "Cleaning up OpenStack"
       @vms.each do |vm|
-        cleanup_storage(vm)
+        cleanup_storage(vm) if @options[:openstack_volume_support]
         @logger.debug "Release floating IPs for OpenStack host #{vm.name}"
         floating_ips = vm.all_addresses # fetch and release its floating IPs
         floating_ips.each do |address|

data/lib/beaker/options/presets.rb

@@ -134,6 +134,7 @@ module Beaker
           :openstack_keyname      => ENV['OS_KEYNAME'],
           :openstack_network      => ENV['OS_NETWORK'],
           :openstack_region       => ENV['OS_REGION'],
+          :openstack_volume_support => ENV['OS_VOLUME_SUPPORT'] || true,
           :jenkins_build_url      => nil,
           :validate               => true,
           :configure              => true,

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '3.15.0'
+    STRING = '3.16.0'
   end
 end

data/spec/beaker/host/cisco_spec.rb

@@ -28,7 +28,7 @@ module Cisco
 
         it 'uses `sudo` if not root' do
           @options = { :user => 'notroot' }
-          answer_correct = "source /etc/profile; sudo sh -c \""
+          answer_correct = "source /etc/profile; sudo -E sh -c \""
           answer_test = host.prepend_commands( 'fake_command' )
           expect( answer_test ).to be === answer_correct
         end

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

@@ -14,6 +14,10 @@ module Beaker
         @hash[k]
       end
 
+      def []=(k, v)
+        @hash[k] = v
+      end
+
       def to_s
         "me"
       end
@@ -93,8 +97,9 @@ module Beaker
       it "checks correctly on sles" do
         @opts = {'platform' => 'sles-is-me'}
         pkg = 'sles_package'
-        expect( Beaker::Command ).to receive(:new).with("zypper se -i --match-exact #{pkg}", [], {:prepend_cmds=>nil, :cmdexe=>false}).and_return('')
-        expect( instance ).to receive(:exec).with('', :accept_all_exit_codes => true).and_return(generate_result("hello", {:exit_code => 0}))
+        expect( Beaker::Command ).to receive( :new ).with( /^rpmkeys.*nightlies.puppetlabs.com.*/, anything, anything ).and_return('').ordered.once
+        expect( Beaker::Command ).to receive(:new).with("zypper --gpg-auto-import-keys se -i --match-exact #{pkg}", [], {:prepend_cmds=>nil, :cmdexe=>false}).and_return('').ordered.once
+        expect( instance ).to receive(:exec).with('', :accept_all_exit_codes => true).and_return(generate_result("hello", {:exit_code => 0})).exactly(2).times
         expect( instance.check_for_package(pkg) ).to be === true
       end
 

data/spec/beaker/hypervisor/openstack_spec.rb

@@ -20,167 +20,219 @@ module Beaker
       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')
-      expect(options['security_group']).to eq(['my_sg', 'default'])
-      expect(options['floating_ip_pool']).to eq('my_pool')
-    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!"')
+    context 'keystone version support' do
+      it 'supports keystone v2' do
+        credentials = openstack.instance_eval('@credentials')
+        expect(credentials[:openstack_user_domain]).to be_nil
+        expect(credentials[:openstack_project_domain]).to be_nil
       end
-    end
 
-    it 'check host options during server creation' do
+      it 'supports keystone v3 with implicit arguments' do
+        v3_options = options
+        v3_options[:openstack_auth_url] = 'https://example.com/identity/v3/auth'
 
-      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 )
+        credentials = OpenStack.new(@hosts, v3_options).instance_eval('@credentials')
+        expect(credentials[:openstack_user_domain]).to eq('Default')
+        expect(credentials[:openstack_project_domain]).to eq('Default')
+      end
 
-      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)
-      )
+      it 'supports keystone v3 with explicit arguments' do
+        v3_options = options
+        v3_options[:openstack_auth_url] = 'https://example.com/identity/v3/auth'
+        v3_options[:openstack_user_domain] = 'acme.com'
+        v3_options[:openstack_project_domain] = 'R&D'
 
-      @hosts.each do |host|
-        allow(host).to receive(:wait_for_port).and_return(true)
+        credentials = OpenStack.new(@hosts, v3_options).instance_eval('@credentials')
+        expect(credentials[:openstack_user_domain]).to eq('acme.com')
+        expect(credentials[:openstack_project_domain]).to eq('R&D')
       end
-
-      openstack.provision
     end
 
-    it 'generates valid keynames during server creation' do
-      # Simulate getting a dynamic IP from OpenStack to test key generation code
-      # after provisioning. See _validate_new_key_pair in openstack/nova for reference
-      mock_ip = double().as_null_object
-      allow( openstack ).to receive( :get_ip ).and_return( mock_ip )
-      allow( mock_ip ).to receive( :ip ).and_return( '172.16.0.1' )
-      openstack.instance_eval('@options')['openstack_keyname'] = nil
-
-      @hosts.each do |host|
-        allow(host).to receive(:wait_for_port).and_return(true)
+    describe '#provision' do
+
+      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')
+        expect(options['security_group']).to eq(['my_sg', 'default'])
+        expect(options['floating_ip_pool']).to eq('my_pool')
       end
 
-      openstack.provision
-
-      @hosts.each do |host|
-        expect(host[:keyname]).to match(/^[_\-0-9a-zA-Z]+$/)
+      it 'check hosts options during initialization' do
+        @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
-    end
 
-    it 'get_ip always allocates a new floatingip' do
-      # Assume beaker is being executed in parallel N times by travis (or similar).
-      # IPs are allocated (but not associated) before an instance is created; it is
-      # hightly possible the first instance will allocate a new IP and create an ssh
-      # key.  While the instance is being created the other N-1 instances come along,
-      # find the unused IP and try to use it as well which causes keyname clashes
-      # and other IP related shenannigans.  Ensure we allocate a new IP each and every
-      # time
-      mock_addresses = double().as_null_object
-      mock_ip = double().as_null_object
-      allow(@compute_client).to receive(:addresses).and_return(mock_addresses)
-      allow(mock_addresses).to receive(:create).and_return(mock_ip)
-      expect(mock_addresses).to receive(:create).exactly(3).times
-      (1..3).each { openstack.get_ip }
-    end
+      it 'check host options during server creation' do
 
-    it 'creates volumes with cinder v1' do
-      # Mock a volume
-      allow(openstack).to receive(:get_volumes).and_return({'volume1' => {'size' => 1000000 }})
+        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' )
 
-      # Stub out the call to create the client and hard code the return value
-      allow(openstack).to receive(:volume_client_create).and_return(nil)
-      client = double().as_null_object
-      openstack.instance_variable_set(:@volume_client, client)
-      allow(openstack).to receive(:get_volume_api_version).and_return(1)
+        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' )
 
-      # Check the parameters are valid, correct 'name' parameter and correct size conversion
-      mock_volume = double().as_null_object
-      expect(client).to receive(:create).with(:display_name => 'volume1', :description => 'Beaker volume: host=alan volume=volume1', :size => 1000).and_return(mock_volume)
-      allow(mock_volume).to receive(:wait_for).and_return(nil)
+        mock_servers = double().as_null_object
+        allow( @compute_client ).to receive( :servers ).and_return( mock_servers )
 
-      # Perform the test!
-      mock_vm = double().as_null_object
-      allow(mock_volume).to receive(:id).and_return('Fake ID')
-      expect(mock_vm).to receive(:attach_volume).with('Fake ID', '/dev/vdb')
+        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)
+        )
 
-      mock_host = double().as_null_object
-      allow(mock_host).to receive(:name).and_return('alan')
+        @hosts.each do |host|
+          allow(host).to receive(:wait_for_port).and_return(true)
+        end
 
-      openstack.provision_storage mock_host, mock_vm
-    end
+        openstack.provision
+      end
 
-    it 'creates volumes with cinder v2' do
-      # Mock a volume
-      allow(openstack).to receive(:get_volumes).and_return({'volume1' => {'size' => 1000000 }})
+      it 'generates valid keynames during server creation' do
+        # Simulate getting a dynamic IP from OpenStack to test key generation code
+        # after provisioning. See _validate_new_key_pair in openstack/nova for reference
+        mock_ip = double().as_null_object
+        allow( openstack ).to receive( :get_ip ).and_return( mock_ip )
+        allow( mock_ip ).to receive( :ip ).and_return( '172.16.0.1' )
+        openstack.instance_eval('@options')['openstack_keyname'] = nil
 
-      # Stub out the call to create the client and hard code the return value
-      allow(openstack).to receive(:volume_client_create).and_return(nil)
-      client = double().as_null_object
-      openstack.instance_variable_set(:@volume_client, client)
-      allow(openstack).to receive(:get_volume_api_version).and_return(-1)
+        @hosts.each do |host|
+          allow(host).to receive(:wait_for_port).and_return(true)
+        end
 
-      # Check the parameters are valid, correct 'name' parameter and correct size conversion
-      mock_volume = double().as_null_object
-      expect(client).to receive(:create).with(:name => 'volume1', :description => 'Beaker volume: host=alan volume=volume1', :size => 1000).and_return(mock_volume)
-      allow(mock_volume).to receive(:wait_for).and_return(nil)
+        openstack.provision
 
-      # Perform the test!
-      mock_vm = double().as_null_object
-      allow(mock_volume).to receive(:id).and_return('Fake ID')
-      expect(mock_vm).to receive(:attach_volume).with('Fake ID', '/dev/vdb')
+        @hosts.each do |host|
+          expect(host[:keyname]).to match(/^[_\-0-9a-zA-Z]+$/)
+        end
+      end
 
-      mock_host = double().as_null_object
-      allow(mock_host).to receive(:name).and_return('alan')
+      it 'get_ip always allocates a new floatingip' do
+        # Assume beaker is being executed in parallel N times by travis (or similar).
+        # IPs are allocated (but not associated) before an instance is created; it is
+        # hightly possible the first instance will allocate a new IP and create an ssh
+        # key.  While the instance is being created the other N-1 instances come along,
+        # find the unused IP and try to use it as well which causes keyname clashes
+        # and other IP related shenannigans.  Ensure we allocate a new IP each and every
+        # time
+        mock_addresses = double().as_null_object
+        mock_ip = double().as_null_object
+        allow(@compute_client).to receive(:addresses).and_return(mock_addresses)
+        allow(mock_addresses).to receive(:create).and_return(mock_ip)
+        expect(mock_addresses).to receive(:create).exactly(3).times
+        (1..3).each { openstack.get_ip }
+      end
 
-      openstack.provision_storage mock_host, mock_vm
+      context 'volume creation option' do
+        it 'provisions volume by default' do
+          mock_flavor = Object.new
+          allow( mock_flavor ).to receive( :id ).and_return( 12345 )
+          allow( openstack ).to receive( :flavor ).and_return( mock_flavor )
+          mock_image = Object.new
+          allow( mock_image ).to receive( :id ).and_return( 54321 )
+          allow( openstack ).to receive( :image ).and_return( mock_image )
+          mock_servers = double().as_null_object
+          allow( @compute_client ).to receive( :servers ).and_return( mock_servers )
+
+          @hosts.each do |host|
+            allow(host).to receive(:wait_for_port).and_return(true)
+            expect(openstack).to receive(:provision_storage)
+          end
+
+          openstack.provision
+        end
+
+        it 'skips provisioning when disabled' do
+          mock_flavor = Object.new
+          allow( mock_flavor ).to receive( :id ).and_return( 12345 )
+          allow( openstack ).to receive( :flavor ).and_return( mock_flavor )
+          mock_image = Object.new
+          allow( mock_image ).to receive( :id ).and_return( 54321 )
+          allow( openstack ).to receive( :image ).and_return( mock_image )
+          mock_servers = double().as_null_object
+          allow( @compute_client ).to receive( :servers ).and_return( mock_servers )
+
+          openstack.instance_eval('@options')['openstack_volume_support'] = false
+
+          @hosts.each do |host|
+            allow(host).to receive(:wait_for_port).and_return(true)
+            expect(openstack).not_to receive(:provision_storage)
+          end
+
+          openstack.provision
+        end
+      end
     end
 
-    it 'supports keystone v2' do
-      credentials = openstack.instance_eval('@credentials')
-      expect(credentials[:openstack_user_domain]).to be_nil
-      expect(credentials[:openstack_project_domain]).to be_nil
-    end
+    describe '#provision_storage' do
 
-    it 'supports keystone v3 with implicit arguments' do
-      v3_options = options
-      v3_options[:openstack_auth_url] = 'https://example.com/identity/v3/auth'
+      it 'creates volumes with cinder v1' do
+        # Mock a volume
+        allow(openstack).to receive(:get_volumes).and_return({'volume1' => {'size' => 1000000 }})
 
-      credentials = OpenStack.new(@hosts, v3_options).instance_eval('@credentials')
-      expect(credentials[:openstack_user_domain]).to eq('Default')
-      expect(credentials[:openstack_project_domain]).to eq('Default')
-    end
+        # Stub out the call to create the client and hard code the return value
+        allow(openstack).to receive(:volume_client_create).and_return(nil)
+        client = double().as_null_object
+        openstack.instance_variable_set(:@volume_client, client)
+        allow(openstack).to receive(:get_volume_api_version).and_return(1)
 
-    it 'supports keystone v3 with explicit arguments' do
-      v3_options = options
-      v3_options[:openstack_auth_url] = 'https://example.com/identity/v3/auth'
-      v3_options[:openstack_user_domain] = 'acme.com'
-      v3_options[:openstack_project_domain] = 'R&D'
+        # Check the parameters are valid, correct 'name' parameter and correct size conversion
+        mock_volume = double().as_null_object
+        expect(client).to receive(:create).with(:display_name => 'volume1',
+                                                :description => 'Beaker volume: host=alan volume=volume1',
+                                                :size => 1000
+                                               ).and_return(mock_volume)
+        allow(mock_volume).to receive(:wait_for).and_return(nil)
 
-      credentials = OpenStack.new(@hosts, v3_options).instance_eval('@credentials')
-      expect(credentials[:openstack_user_domain]).to eq('acme.com')
-      expect(credentials[:openstack_project_domain]).to eq('R&D')
-    end
+        # Perform the test!
+        mock_vm = double().as_null_object
+        allow(mock_volume).to receive(:id).and_return('Fake ID')
+        expect(mock_vm).to receive(:attach_volume).with('Fake ID', '/dev/vdb')
+
+        mock_host = double().as_null_object
+        allow(mock_host).to receive(:name).and_return('alan')
+
+        openstack.provision_storage mock_host, mock_vm
+      end
 
+      it 'creates volumes with cinder v2' do
+        # Mock a volume
+        allow(openstack).to receive(:get_volumes).and_return({'volume1' => {'size' => 1000000 }})
+
+        # Stub out the call to create the client and hard code the return value
+        allow(openstack).to receive(:volume_client_create).and_return(nil)
+        client = double().as_null_object
+        openstack.instance_variable_set(:@volume_client, client)
+        allow(openstack).to receive(:get_volume_api_version).and_return(-1)
+
+        # Check the parameters are valid, correct 'name' parameter and correct size conversion
+        mock_volume = double().as_null_object
+        expect(client).to receive(:create).with(:name => 'volume1',
+                                                :description => 'Beaker volume: host=alan volume=volume1',
+                                                :size => 1000
+                                               ).and_return(mock_volume)
+        allow(mock_volume).to receive(:wait_for).and_return(nil)
+
+        # Perform the test!
+        mock_vm = double().as_null_object
+        allow(mock_volume).to receive(:id).and_return('Fake ID')
+        expect(mock_vm).to receive(:attach_volume).with('Fake ID', '/dev/vdb')
+
+        mock_host = double().as_null_object
+        allow(mock_host).to receive(:name).and_return('alan')
+
+        openstack.provision_storage mock_host, mock_vm
+      end
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beaker
 version: !ruby/object:Gem::Version
-  version: 3.15.0
+  version: 3.16.0
 platform: ruby
 authors:
 - Puppet
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-04-19 00:00:00.000000000 Z
+date: 2017-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -583,6 +583,7 @@ files:
 - docs/tutorials/installation.md
 - docs/tutorials/lets_write_a_test.md
 - docs/tutorials/quick_start_rake_tasks.md
+- docs/tutorials/subcommands.md
 - docs/tutorials/test_run.md
 - docs/tutorials/test_suites.md
 - docs/tutorials/the_command_line.md