beaker 3.34.0 → 3.35.0

data/docs/how_to/upgrade_from_2_to_3.md

@@ -1,8 +1,8 @@
 # How To Upgrade from 2.y to 3.0
 
 This is a guide detailing all the issues to be aware of, and to help people make
-any changes that you might need to move from beaker 2.y to 3.0. To test out 
-beaker 3.0.0, we recommend implementing the strategy outlined [here](test_arbitrary_beaker_versions.md) 
+any changes that you might need to move from beaker 2.y to 3.0. To test out
+beaker 3.0.0, we recommend implementing the strategy outlined [here](test_arbitrary_beaker_versions.md)
 to ensure this new major release does not break your existing testing.
 
 ## Ruby version 1.9.3 no longer supported
@@ -39,10 +39,10 @@ doc for info on how to do this.
 
 ## EPEL package update
 
-In beaker < 3.0.0, the epel package names had hardcoded defaults listed in the 
+In beaker < 3.0.0, the epel package names had hardcoded defaults listed in the
 presets default; in beaker >= 3.0.0, beaker utilizes the `release-latest` file
 provided on epel mirrors for el versions 5, 6, and 7. Since only the latest epel
-packages are available on epel mirrors, beaker only supports installation of 
+packages are available on epel mirrors, beaker only supports installation of
 that latest version.
 
 ## Solaris and AIX Hypervisors removed

data/docs/tutorials/README.md

@@ -22,7 +22,7 @@ If you haven't installed beaker yet, your guide to doing
 so can be found [here](installation.md).
 
 ## Quick Start
- 
+
 As a completely new beaker user, the
 [quick start rake tasks doc](quick_start_rake_tasks.md)
 will take you through getting beaker running for the

data/docs/tutorials/test_suites.md

@@ -47,7 +47,7 @@ failure modes.
 
 The pre-suite is for setting up the Systems Under Test (SUTs) for the testing
 suite. No surprises here, usually these files are filled with the setup and
-installation code needed to verify that the operating assumptions of the 
+installation code needed to verify that the operating assumptions of the
 software being tested are true.
 
 Pre-suites, since they’re supposed to contain just setup code, will fail-fast

data/lib/beaker/cli.rb

@@ -16,6 +16,7 @@ module Beaker
       # the options are parsed and replaced with a new logger based on what is passed
       # in to configure the logger.
       @logger = Beaker::Logger.new
+      @options = {}
     end
 
     def parse_options

data/lib/beaker/command.rb

@@ -66,7 +66,7 @@ module Beaker
     #                      interface.
     # @param [String] cmd  An command to call.
     # @param [Hash]   env  An optional hash of environment variables to be used
-    # @param [String] pc   An optional list of commands to prepend 
+    # @param [String] pc   An optional list of commands to prepend
     #
     # @return [String] This returns the fully formed command line invocation.
     def cmd_line host, cmd = @command, env = @environment, pc = @prepend_cmds
@@ -78,7 +78,7 @@ module Beaker
       end
 
       # This will cause things like `puppet -t -v agent` which is maybe bad.
-      if host[:platform] =~ /cisco_ios_xr/ 
+      if host[:platform] =~ /cisco_ios_xr/
         cmd_line_array = [prepend_commands, env_string, cmd, options_string, args_string]
       else
         cmd_line_array = [env_string, prepend_commands, cmd, options_string, args_string]

data/lib/beaker/dsl/assertions.rb

@@ -98,7 +98,7 @@ module Beaker
       # Assert that the provided string does not match the provided regular expression, can pass optional message
       # @deprecated This is placed her for backwards compatability for tests that used Test::Unit::Assertions,
       #             http://apidock.com/ruby/Test/Unit/Assertions/assert_no_match
-      #             
+      #
       def assert_no_match(regexp, string, msg=nil)
         assert_instance_of(Regexp, regexp, "The first argument to assert_no_match should be a Regexp.")
         msg = message(msg) { "<#{mu_pp(regexp)}> expected to not match\n<#{mu_pp(string)}>" }

data/lib/beaker/dsl/helpers/facter_helpers.rb

@@ -13,7 +13,7 @@ module Beaker
         #     (or range) of integer exit codes that should be considered
         #     acceptable.  An error will be thrown if the exit code does not
         #     match one of the values in this list.
-        #   @option opts [Boolean] :accept_all_exit_codes (false) Consider all 
+        #   @option opts [Boolean] :accept_all_exit_codes (false) Consider all
         #     exit codes as passing.
         #   @option opts [Boolean] :dry_run (false) Do not actually execute any
         #     commands on the SUT

data/lib/beaker/dsl/install_utils/pe_defaults.rb

@@ -72,7 +72,7 @@ module Beaker
           PE_DEFAULTS[platform].each_pair do |key, val|
             host[key] = val
           end
-          # add the type and group here for backwards compatability 
+          # add the type and group here for backwards compatability
           if host['platform'] =~ /windows/
             host['group'] = 'Administrators'
           else

data/lib/beaker/dsl/roles.rb

@@ -161,7 +161,7 @@ module Beaker
       end
 
       #Create a new role method for a given arbitrary role name.  Makes it possible to be able to run
-      #commands without having to refer to role by String or Symbol.  Will not add a new method 
+      #commands without having to refer to role by String or Symbol.  Will not add a new method
       #definition if the name is already in use.
       # @param [String, Symbol, Array[String,Symbol]] role The role that you wish to create a definition for, either a String
       # Symbol or an Array of Strings or Symbols.

data/lib/beaker/dsl/structure.rb

@@ -68,7 +68,7 @@ module Beaker
 
         set_current_step_name(step_name)
         # Here we prompt the user to tell us if the step passed or failed
-        loop do 
+        loop do
           input = Readline.readline('Did this step pass, Y/n? ', true).squeeze(" ").strip.downcase
           if %w(y yes).include?(input)
             break
@@ -102,7 +102,7 @@ module Beaker
       def manual_test manual_test_name, &block
         if(@options.has_key?(:exec_manual_tests) && @options[:exec_manual_tests] == true)
           # here the option is set so we run the test as normal
-          test_name manual_test_name, &block 
+          test_name manual_test_name, &block
         else
           # here no option was set so we log the test name and skip it
           test_name manual_test_name

data/lib/beaker/host/cisco.rb

@@ -119,15 +119,15 @@ module Cisco
     #   this will be raised with the appropriate message
     def validate_setup
       msg = nil
-      if self[:platform] =~ /cisco_nexus/ 
+      if self[:platform] =~ /cisco_nexus/
         if !self[:vrf]
-          msg = 'Cisco Nexus hosts must be provided with a :vrf value.' 
+          msg = 'Cisco Nexus hosts must be provided with a :vrf value.'
         end
         if !self[:user]
           msg = 'Cisco hosts must be provided with a :user value'
         end
       end
-      if self[:platform] =~ /cisco_ios_xr/ 
+      if self[:platform] =~ /cisco_ios_xr/
         if !self[:user]
           msg = 'Cisco hosts must be provided with a :user value'
         end

data/lib/beaker/host/mac/exec.rb

@@ -30,7 +30,7 @@ module Mac::Exec
   # Checks if selinux is enabled
   # selinux is not availble on OS X
   #
-  # @return [Boolean] false 
+  # @return [Boolean] false
   def selinux_enabled?()
     false
   end

data/lib/beaker/host/windows/exec.rb

@@ -113,7 +113,7 @@ module Windows::Exec
   #
   # @return [Boolean]
   def cygwin_installed?
-    output = exec(Beaker::Command.new('cygcheck --check-setup cygwin'), :accept_all_exit_codes => true).stdout 
+    output = exec(Beaker::Command.new('cygcheck --check-setup cygwin'), :accept_all_exit_codes => true).stdout
     return true if output.match(/cygwin/) && output.match(/OK/)
     false
   end

data/lib/beaker/host_prebuilt_steps.rb

@@ -432,6 +432,9 @@ module Beaker
         elsif host['platform'] =~ /solaris-11/
           host.exec(Command.new("if grep \"root::::type=role\" /etc/user_attr; then sudo rolemod -K type=normal root; else echo \"root user already type=normal\"; fi"), {:pty => true} )
           host.exec(Command.new("sudo gsed -i -e 's/PermitRootLogin no/PermitRootLogin yes/g' /etc/ssh/sshd_config"), {:pty => true} )
+        elsif host['platform'] =~ /f5/
+          #interacting with f5 should using tmsh
+          logger.warn("Attempting to enable root login non-supported platform: #{host.name}: #{host['platform']}")
         elsif host.is_cygwin?
           host.exec(Command.new("sed -ri 's/^#?PermitRootLogin /PermitRootLogin yes/' /etc/sshd_config"), {:pty => true})
         elsif host.is_powershell?

data/lib/beaker/options/hosts_file_parser.rb

@@ -14,12 +14,17 @@ module Beaker
       # @raise [ArgumentError] Raises if hosts_file_path is not a valid YAML file
       # @raise [Errno::ENOENT] File not found error: hosts_file doesn't exist
       def self.parse_hosts_file(hosts_file_path = nil)
+        require 'erb'
+
         host_options = new_host_options
         return host_options unless hosts_file_path
         error_message = "#{hosts_file_path} is not a valid YAML file\n\t"
         host_options = self.merge_hosts_yaml( host_options, error_message ) {
           hosts_file_path = File.expand_path( hosts_file_path )
-          YAML.load_file( hosts_file_path )
+
+          raise "#{hosts_file_path} is not a valid path" unless File.exist?(hosts_file_path)
+
+          YAML.load(ERB.new(File.read(hosts_file_path), nil, '-').result(binding))
         }
         fix_roles_array( host_options )
       end
@@ -31,11 +36,13 @@ module Beaker
       # @return [OptionsHash] Contents of the hosts file as an OptionsHash
       # @raise [ArgumentError] If hosts_def_yaml is not a valid YAML string
       def self.parse_hosts_string(hosts_def_yaml = nil)
+        require 'erb'
+
         host_options = new_host_options
         return host_options unless hosts_def_yaml
         error_message = "#{hosts_def_yaml}\nis not a valid YAML string\n\t"
         host_options = self.merge_hosts_yaml( host_options, error_message ) {
-          YAML.load( hosts_def_yaml )
+          YAML.load(ERB.new(hosts_def_yaml, nil, '-').result(binding))
         }
         fix_roles_array( host_options )
       end

data/lib/beaker/options/parser.rb

@@ -171,7 +171,7 @@ module Beaker
 
       # Update the @attribution hash with the source of each key in the options_hash
       #
-      # @param [Hash] options_hash Options hash 
+      # @param [Hash] options_hash Options hash
       # @param [String] source Where the options were specified
       # @return [Hash] hash Hash of sources for each key
       def tag_sources(options_hash, source)

data/lib/beaker/shared/options_resolver.rb

@@ -3,25 +3,25 @@ module Beaker
     # Methods for parsing options.
     module OptionsResolver
       # parses local and global options to determine if a particular mode should
-      # be run in parallel. typically, local_options will specify a true/false 
+      # be run in parallel. typically, local_options will specify a true/false
       # value, while global_options will specify an array of mode names that should
       # be run in parallel. the value specified in local_options will take precedence
-      # over the values specified in global_options. 
+      # over the values specified in global_options.
       # @param [Hash] local_options local options for running in parallel
       # @option local_options [Boolean] :run_in_parallel flag for running in parallel
       # @param [Hash] global_options global options for running in parallel
       # @option global_options [Array<String>] :run_in_parallel list of modes to run in parallel
       # @param [String] mode the mode we want to query global_options for
-      # @return [Boolean] true if the specified mode is in global_options and :run_in_parallel in local_options is not false, 
+      # @return [Boolean] true if the specified mode is in global_options and :run_in_parallel in local_options is not false,
       #   or if :run_in_parallel in local_options is true, false otherwise
       # @example
-      #   run_in_parallel?({:run_in_parallel => true}) 
+      #   run_in_parallel?({:run_in_parallel => true})
       #   -> will return true
       #
-      #   run_in_parallel?({:run_in_parallel => true}, {:run_in_parallel => ['install','configure']}, 'install') 
+      #   run_in_parallel?({:run_in_parallel => true}, {:run_in_parallel => ['install','configure']}, 'install')
       #   -> will return true
       #
-      #   run_in_parallel?({:run_in_parallel => false}, {:run_in_parallel => ['install','configure']}, 'install') 
+      #   run_in_parallel?({:run_in_parallel => false}, {:run_in_parallel => ['install','configure']}, 'install')
       #   -> will return false
       def run_in_parallel?(local_options=nil, global_options=nil, mode=nil)
         run_in_parallel = local_options[:run_in_parallel] unless local_options.nil?

data/lib/beaker/subcommand.rb

@@ -6,6 +6,7 @@ module Beaker
   class Subcommand < Thor
     SubcommandUtil = Beaker::Subcommands::SubcommandUtil
 
+    attr_reader :cli
 
     def initialize(*args)
       super
@@ -171,8 +172,9 @@ module Beaker
       end
 
       beaker_suites = [:pre_suite, :tests, :post_suite, :pre_cleanup]
-
-      if Pathname(resource).exist?
+      resources = resource.split(',')
+      paths = resources.map { |r| Pathname(r) }
+      if paths.all?(&:exist?)
         # If we determine the resource is a valid file resource, then we empty
         # all the suites and run that file resource in the tests suite. In the
         # future, when we have the ability to have custom suites, we should change
@@ -180,12 +182,14 @@ module Beaker
         beaker_suites.each do |suite|
           @cli.options[suite] = []
         end
-        if Pathname(resource).directory?
-          @cli.options[:tests] = Dir.glob("#{Pathname(resource)}/**/*.rb")
-        else
-          @cli.options[:tests] = [Pathname(resource).to_s]
-        end
-      elsif resource.match(/pre-suite|tests|post-suite|pre-cleanup/)
+        @cli.options[:tests] = paths.map do |path|
+          if path.directory?
+            Dir.glob("#{path}/**/*.rb")
+          else
+            path.to_s
+          end
+        end.flatten
+      elsif resources.all? { |r| r =~ /^(pre-suite|tests|post-suite|pre-cleanup)$/ }
         # The regex match here is loose so that users can supply multiple suites,
         # such as `beaker exec pre-suite,tests`.
         beaker_suites.each do |suite|
@@ -194,6 +198,7 @@ module Beaker
       else
         raise ArgumentError, "Unable to parse #{resource} with beaker exec"
       end
+
       @cli.execute!
     end
 

data/lib/beaker/tasks/quick_start.rb

@@ -50,11 +50,11 @@ namespace :beaker_quickstart do
 
   desc 'Generate Default Smoke Test'
   task :gen_smoke_test do
-    smoke_test_file = "acceptance/setup/default_smoke_test.rb"
+    smoke_test_file = "acceptance/tests/default_smoke_test.rb"
     FileUtils.mkdir_p('acceptance/tests') # -p ignores when dir already exists
     if !File.exist?(smoke_test_file) then
       puts "Writing default smoke test to file - #{smoke_test_file}"
-      File.open("acceptance/tests/default_smoke_test.rb", 'w') do |fh|
+      File.open(smoke_test_file, 'w') do |fh|
         fh.print("test_name 'puppet install smoketest' do
   step 'puppet install smoketest: verify \\'puppet help\\' can be successfully called on
   all hosts' do

data/lib/beaker/version.rb

@@ -1,5 +1,5 @@
 module Beaker
   module Version
-    STRING = '3.34.0'
+    STRING = '3.35.0'
   end
 end

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

@@ -102,7 +102,7 @@ module Beaker
     describe '#ssh_service_restart' do
       PlatformHelpers::SYSTEMDPLATFORMS.each do |platform|
         it "calls the correct command for #{platform}" do
-          opts['platform'] = platform 
+          opts['platform'] = platform
           expect(instance).to receive(:exec)
           expect(Beaker::Command).to receive(:new).with("systemctl restart sshd.service")
           expect{instance.ssh_service_restart}.to_not raise_error

data/spec/beaker/host_prebuilt_steps_spec.rb

@@ -38,6 +38,7 @@ describe Beaker do
     end
   end
 
+  it_should_behave_like 'enables_root_login', 'f5', []
   # Non-cygwin Windows
   it_should_behave_like 'enables_root_login', 'pswindows', [], false
 

data/spec/beaker/options/hosts_file_parser_spec.rb

@@ -28,14 +28,14 @@ module Beaker
 
         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)
+          expect{parser.parse_hosts_file("not a valid path")}.to raise_error(/is not a valid path/)
         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)
+          expect( File ).to receive(:exist?).and_return(true)
+
+          expect { parser.parse_hosts_file("not a valid path") }.to raise_error(Errno::ENOENT)
         end
 
         it 'returns a #new_host_options hash if given no arguments' do
@@ -43,12 +43,20 @@ module Beaker
           expect( host_options ).to be === parser.new_host_options
         end
 
-        it 'passes a YAML.load_file call through to #merge_hosts_yaml' do
+        it 'passes a YAML.load 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 )
+          expect( File ).to receive( :exist?).and_return(true)
+          expect( File ).to receive( :read ).and_return(yaml_string)
           parser.parse_hosts_file( yaml_string )
         end
+
+        it 'processes ERB in the host YAML successfully' do
+          yaml_string = '1 plus 2: <%= 1 + 2 %>'
+          expect( File ).to receive( :exist?).and_return(true)
+          expect( File ).to receive( :read ).and_return(yaml_string)
+          beaker_options_hash = parser.parse_hosts_file( yaml_string )
+          expect(beaker_options_hash['1 plus 2']).to eq(3)
+        end
       end
 
       describe '#parse_hosts_string' do

data/spec/beaker/shared/error_handler_spec.rb

@@ -19,14 +19,14 @@ module Beaker
           ex = Exception.new("ArgumentError")
           allow( ex ).to receive( :backtrace ).and_return(backtrace)
           mesg = "I'm the extra message"
-         
+
           backtrace.each_line do |line|
             expect( logger ).to receive( :error ).with(line)
           end
 
           expect( subject ).to receive( :raise ).once
 
-          subject.report_and_raise(logger, ex, mesg) 
+          subject.report_and_raise(logger, ex, mesg)
 
         end
 

data/spec/beaker/shared/repetition_spec.rb

@@ -10,7 +10,7 @@ module Beaker
 
           block = double( 'block' )
           expect( block ).to receive( :exec ).exactly( 5 ).times.and_return( false )
-          
+
           subject.repeat_for( 5 ) do
             block.exec
           end
@@ -21,7 +21,7 @@ module Beaker
 
           block = double( 'block' )
           expect( block ).to receive( :exec ).once.and_return( true )
-          
+
           subject.repeat_for( 5 ) do
             block.exec
           end

data/spec/beaker/subcommand_spec.rb

@@ -9,9 +9,9 @@ module Beaker
 
     context '#initialize' do
       it 'creates a cli object' do
-        expect(Beaker::CLI).to receive(:new).once
-        subcommand
+        expect(subcommand.cli).to be
       end
+
       describe 'File operation initialization for subcommands' do
         it 'checks to ensure subcommand file resources exist' do
           expect(FileUtils).to receive(:mkdir_p).with(SubcommandUtil::CONFIG_DIR)
@@ -28,7 +28,6 @@ module Beaker
           expect(FileUtils).to receive(:touch).with(SubcommandUtil::SUBCOMMAND_STATE)
           subcommand
         end
-
       end
     end
 
@@ -80,6 +79,9 @@ module Beaker
 
       it 'should not error with valid beaker options' do
         beaker_options_list.each do |option|
+          allow_any_instance_of(Beaker::CLI).to receive(:parse_options)
+          allow_any_instance_of(Beaker::CLI).to receive(:configured_options).and_return({})
+
           allow(YAML::Store).to receive(:new).with(SubcommandUtil::SUBCOMMAND_STATE).and_return(yaml_store_mock)
           allow(yaml_store_mock).to receive(:transaction).and_yield
           allow(yaml_store_mock).to receive(:[]=).with('provisioned', false)
@@ -87,6 +89,7 @@ module Beaker
           allow_any_instance_of(Beaker::Logger).to receive(:notify).twice
           expect(SubcommandUtil::SUBCOMMAND_OPTIONS).to receive(:exist?).and_return(true)
           expect(SubcommandUtil::SUBCOMMAND_STATE).to receive(:exist?).and_return(true)
+
           expect {Beaker::Subcommand.start(['init', '--hosts', 'centos', "--#{option}"])}.to_not output(/ERROR/).to_stderr
         end
       end
@@ -103,13 +106,16 @@ module Beaker
     end
 
     context '#init' do
-      let( :cli ) { subcommand.instance_variable_get(:@cli) }
+      let( :cli ) { subcommand.cli }
       let( :mock_options ) { {:timestamp => 'noon', :other_key => 'cordite'}}
       let( :yaml_store_mock ) { double('yaml_store_mock') }
-      it 'calculates options and writes them to disk and deletes the' do
-        expect(cli).to receive(:parse_options)
+
+      before :each do
+        allow(cli).to receive(:parse_options)
         allow(cli).to receive(:configured_options).and_return(mock_options)
+      end
 
+      it 'calculates options and writes them to disk and deletes the' do
         allow(File).to receive(:open)
         allow(YAML::Store).to receive(:new).with(SubcommandUtil::SUBCOMMAND_STATE).and_return(yaml_store_mock)
         allow(yaml_store_mock).to receive(:transaction).and_yield
@@ -117,13 +123,14 @@ module Beaker
         subcommand.init
         expect(mock_options).not_to have_key(:timestamp)
       end
+
       it 'requires hosts flag' do
         expect{subcommand.init}.to raise_error(NotImplementedError)
       end
     end
 
     context '#provision' do
-      let ( :cli ) { subcommand.instance_variable_get(:@cli) }
+      let ( :cli ) { subcommand.cli }
       let( :yaml_store_mock ) { double('yaml_store_mock') }
       let ( :host_hash ) { {'mynode.net' => {:name => 'mynode', :platform => Beaker::Platform.new('centos-6-x86_64')}}}
       let ( :cleaned_hosts ) {double()}
@@ -133,6 +140,7 @@ module Beaker
       let ( :hosts) {double('hosts')}
       let ( :hypervisors) {double('hypervisors')}
       let (:options) {double ('options')}
+
       it 'provisions the host and saves the host info' do
         expect(YAML::Store).to receive(:new).with(SubcommandUtil::SUBCOMMAND_STATE).and_return(yaml_store_mock)
         allow(yaml_store_mock).to receive(:[]).and_return(false)
@@ -157,59 +165,103 @@ module Beaker
         expect(yaml_store_mock).to receive(:[]=).with('provisioned', true)
         subcommand.provision
       end
+
       it 'does not allow hosts to be passed' do
         subcommand.options = {:hosts => "myhost"}
         expect{subcommand.provision()}.to raise_error(NotImplementedError)
       end
     end
 
-
     context 'exec' do
+      before :each do
+        allow(subcommand.cli).to receive(:parse_options)
+        allow(subcommand.cli).to receive(:initialize_network_manager)
+      end
+
       it 'calls execute! when no resource is given' do
         expect_any_instance_of(Pathname).to_not receive(:directory?)
         expect_any_instance_of(Pathname).to_not receive(:exist?)
-        expect_any_instance_of(Beaker::CLI).to receive(:parse_options).once
-        expect_any_instance_of(Beaker::CLI).to receive(:initialize_network_manager).once
-        expect_any_instance_of(Beaker::CLI).to receive(:execute!).once
+        expect(subcommand.cli).to receive(:execute!).once
         expect{subcommand.exec}.to_not raise_error
       end
 
-      it 'checks to to see if the resource is a file_resource' do
+      it 'allows hard coded suite names to be specified' do
+        subcommand.cli.options[:pre_suite] = %w[step1.rb]
+        subcommand.cli.options[:post_suite] = %w[step2.rb]
+        subcommand.cli.options[:tests] = %w[tests/1.rb]
+
+        subcommand.exec('pre-suite,tests')
+
+        expect(subcommand.cli.options[:pre_suite]).to eq(%w[step1.rb])
+        expect(subcommand.cli.options[:post_suite]).to eq([])
+        expect(subcommand.cli.options[:tests]).to eq(%w[tests/1.rb])
+      end
+
+      it 'errors when a resource is neither a valid file resource or suite name' do
+        allow_any_instance_of(Pathname).to receive(:exist?).and_return(false)
+        expect{subcommand.exec('blahblahblah')}.to raise_error(ArgumentError)
+      end
 
-        expect_any_instance_of(Pathname).to receive(:exist?).and_return(true)
-        expect_any_instance_of(Pathname).to receive(:directory?).and_return(false)
-        expect_any_instance_of(Beaker::CLI).to receive(:execute!).once
-        expect{subcommand.exec('resource')}.to_not raise_error
+      it 'accepts a tests directory, clearing all other suites' do
+        allow_any_instance_of(Pathname).to receive(:exist?).and_return(true)
+        allow_any_instance_of(Pathname).to receive(:directory?).and_return(true)
+        allow(Dir).to receive(:glob)
+          .with('tests/**/*.rb')
+          .and_return(%w[tests/a.rb tests/b/c.rb])
+
+        subcommand.exec('tests')
+
+        expect(subcommand.cli.options[:pre_suite]).to eq([])
+        expect(subcommand.cli.options[:post_suite]).to eq([])
+        expect(subcommand.cli.options[:pre_cleanup]).to eq([])
+        expect(subcommand.cli.options[:tests]).to eq(%w[tests/a.rb tests/b/c.rb])
       end
 
-      it 'checks to see if the resource is a directory' do
-        expect_any_instance_of(Pathname).to receive(:exist?).and_return(true)
-        expect_any_instance_of(Pathname).to receive(:directory?).and_return(true)
-        expect(Dir).to receive(:glob)
-        expect_any_instance_of(Beaker::CLI).to receive(:execute!).once
-        expect{subcommand.exec('resource')}.to_not raise_error
+      it 'accepts comma-separated list of tests, clearing all other suites' do
+        allow_any_instance_of(Pathname).to receive(:exist?).and_return(true)
+        allow_any_instance_of(Pathname).to receive(:file?).and_return(true)
+
+        subcommand.exec('tests/1.rb,tests/2.rb')
+
+        expect(subcommand.cli.options[:pre_suite]).to eq([])
+        expect(subcommand.cli.options[:post_suite]).to eq([])
+        expect(subcommand.cli.options[:pre_cleanup]).to eq([])
+        expect(subcommand.cli.options[:tests]).to eq(%w[tests/1.rb tests/2.rb])
       end
 
-      it 'allows a hard coded suite name to be specified' do
+      it 'accepts comma-separated list of directories, recursively scanning each' do
+        allow_any_instance_of(Pathname).to receive(:exist?).and_return(true)
+        allow_any_instance_of(Pathname).to receive(:directory?).and_return(true)
+        allow(Dir).to receive(:glob).with('tests/a/**/*.rb').and_return(%w[tests/a/x.rb])
+        allow(Dir).to receive(:glob).with('tests/b/**/*.rb').and_return(%w[tests/b/x/y.rb tests/b/x/z.rb])
 
-        allow_any_instance_of(Pathname).to receive(:exist?).and_return(false)
-        expect_any_instance_of(Beaker::CLI).to receive(:execute!).once
-        expect{subcommand.exec('tests')}.to_not raise_error
+        subcommand.exec('tests/a,tests/b')
+
+        expect(subcommand.cli.options[:tests]).to eq(%w[tests/a/x.rb tests/b/x/y.rb tests/b/x/z.rb])
       end
 
-      it 'errors when a resource is neither a valid file resource or suite name' do
+      it 'rejects comma-separated file and suite name' do
         allow_any_instance_of(Pathname).to receive(:exist?).and_return(false)
-        expect{subcommand.exec('blahblahblah')}.to raise_error(ArgumentError)
+
+        expect {
+          subcommand.exec('pre-suite,tests/whoops')
+        }.to raise_error(ArgumentError, %r{Unable to parse pre-suite,tests/whoops})
       end
     end
 
     context 'destroy' do
-      let( :cli ) { subcommand.instance_variable_get(:@cli) }
+      let( :cli ) { subcommand.cli }
       let( :mock_options ) { {:timestamp => 'noon', :other_key => 'cordite'}}
       let( :yaml_store_mock ) { double('yaml_store_mock') }
+      let( :network_manager) {double('network_manager')}
+
       it 'calls destroy and updates the yaml store' do
+        allow(cli).to receive(:parse_options)
+        allow(cli).to receive(:initialize_network_manager)
+        allow(cli).to receive(:network_manager).and_return(network_manager)
+        expect(network_manager).to receive(:cleanup)
+
         expect(YAML::Store).to receive(:new).with(SubcommandUtil::SUBCOMMAND_STATE).and_return(yaml_store_mock)
-        allow(SubcommandUtil).to receive(:cleanup).with(cli).and_return(true)
         allow(yaml_store_mock).to receive(:transaction).and_yield
         allow(yaml_store_mock).to receive(:[]).with('provisioned').and_return(true)
         allow(yaml_store_mock).to receive(:delete).with('provisioned').and_return(true)