beaker-pe 1.8.2 → 1.9.0

checksums.yaml

@@ -1,15 +1,15 @@
 ---
 !binary "U0hBMQ==":
   metadata.gz: !binary |-
-    MzRjNmZhOThhNGRhMGViOTQ0OGIzZTcyZjMxNDg5NGI3MTNhNWI0MQ==
+    ZmFlZGQ3MDE2NWE4ZmIxNWU5MDE2ODA1MTU4ZTQ0ZDY5ZTBlNGY2Yg==
   data.tar.gz: !binary |-
-    YTRjZTBlZGU0MjgzZTc2ODhhY2JlMWIxMjMwNjRkZmQzN2Q3MDczMQ==
+    ZDExNTM0OTE1NzA4ODA2ZWMzMWY1MWVkOWQyMTZlOGMwYjAwOTBhZQ==
 SHA512:
   metadata.gz: !binary |-
-    M2ExNTJjNTNjZWY0ZDc0MmQ1NTcwMjkxYzliNTBkN2VhZGIyNzBlMDRjMjZh
-    OGM0OWVmMGJlMmI2ODZhZjg3N2U4OTE5ZmZlZjcyNmZiNDYwZDg3ZDcyMjJk
-    MjU4YTg5OTZkMzQwNTdlNzZlZmQwMjczYzE4ODlkYTU3MjBhNjc=
+    ZTdiZWE2ZDliZWFlNDMwNDJiNWNhM2RjYzQ5MjUwZGU2ZGIyMTg0ZmRkZmQz
+    ZjBjYzcwYmE4YTcwOGQ4MmFlOTg3MDJmYjllOTIzMmFiOGU3MTQ0MmFjNTA0
+    NTIzZGVjZmNkNGQ3NzczNDJlYjZmNzliNzRjM2MwYjdiMzM2ODQ=
   data.tar.gz: !binary |-
-    ZWUxNWVkZjk4N2ZkZmIzYjJmY2I0MGYwMzI4ZTJlNDMyYjg5ZGJlMTY3Zjcy
-    NTBiYmY1N2ViMDRkOGMyNmRhODVlNDZkMDQwODZjMTU4OTQzMzc2ODNjZGZi
-    MzdkYThkZjUxMTA1N2UxOTM1OTUwMGQwMGM0NGM5OWQ0ZmVlZDc=
+    ZmYzOGFkMjA1YTE3NjAzZTUwNDMwYWVlZTcyYWRmZTVjZDBiNmNiZTU5NjE2
+    ODUwYmU1YmQ1NjY4ZmUwZTQzN2UwMjc5ZGExYjkyNTgyNjJhMmU1MjNjODcy
+    ZmJmYTZmZmY3MTZlZmI0MDBhMGFmODBhMTg2MzFiOWMzMGQyODk=

data/HISTORY.md

@@ -1,6 +1,7 @@
-# default - History
+# worker - History
 ## Tags
-* [LATEST - 6 Jan, 2017 (93ef8841)](#LATEST)
+* [LATEST - 7 Feb, 2017 (d5c96d6b)](#LATEST)
+* [1.8.2 - 6 Jan, 2017 (625c17e3)](#1.8.2)
 * [1.8.1 - 30 Dec, 2016 (3cefad28)](#1.8.1)
 * [1.8.0 - 30 Dec, 2016 (5a37fef7)](#1.8.0)
 * [1.7.0 - 20 Dec, 2016 (99e6bbde)](#1.7.0)
@@ -29,7 +30,85 @@
 * [0.1.0 - 29 Feb, 2016 (4fc88d8c)](#0.1.0)
 
 ## Details
-### <a name = "LATEST">LATEST - 6 Jan, 2017 (93ef8841)
+### <a name = "LATEST">LATEST - 7 Feb, 2017 (d5c96d6b)
+
+* (GEM) update beaker-pe version to 1.9.0 (d5c96d6b)
+
+* (PE-19169) Add pe modules next flag (#55) (3ff8a996)
+
+
+```
+(PE-19169) Add pe modules next flag (#55)
+
+* (PE-19169,PE-18516) Remove version specific upgrade hack
+
+This had been added to allow upgrade testing in flanders with meep for
+classification prior to our having completed an upgrade workflow in the
+installer.
+
+Now that meep is being worked on in the pe-modules-next package behind a
+feature-flag, this gate is counter-productive, particularly for Flanders
+upgrade testing because it masks the common case of upgrading without
+specifying a pe.conf.
+
+* (PE-19169) Register flag for pe-modules-next if present in ENV
+
+Major PE modules development work is being done in a separate
+pe-modules-next package. The installer shim decides which pe-modules
+package to install based on a pe.conf flag. This patch allows Jenkins CI
+to trigger this by picking up ENV['PE_MODULES_NEXT'] and ensure that the
+flag is set in the opts[:answers] which will then be transferred to
+pe.conf by beaker-answers, and then picked up by the installer shim
+during installation.
+
+* (PE-19169) Ensure beaker-answers generates meep 2.0 schema
+
+...if we are installing with the pe_modules_next flag.
+
+The pe-modules-next is meep classification at the moment and needs a 2.0
+pe.conf generated.
+
+* (PE-19169) Extract a FeatureFlags class
+
+to make it easier to test. Flags can be set in the :answers Hash or
+picked up from environment variables. In the later case, we need to be
+able to preserver them in the :answers hash, if not already present, so
+that BeakerAnswers ensures that they are set in the generated pe.conf
+file.
+```
+* Merge pull request #54 from branan/bkr-937-aix-7.2 (4e381151)
+
+
+```
+Merge pull request #54 from branan/bkr-937-aix-7.2
+
+(BKR-937) Add support for installing AIX 7 agent on 7.2
+```
+* (maint) login_with_puppet_access_on should respect --lifetime flag (with spec tests) (#52) (c17a8daf)
+
+
+```
+(maint) login_with_puppet_access_on should respect --lifetime flag (with spec tests) (#52)
+
+* (maint) fix puppet access helper to respect lifetime argument
+
+* (maint) Add spec tests for login_with_puppet_access_on
+```
+* (BKR-937) Add support for installing AIX 7 agent on 7.2 (9aada073)
+
+
+```
+(BKR-937) Add support for installing AIX 7 agent on 7.2
+
+To avoid unnecessarily expanding our build times, our initial support
+for AIX 7.2 is through the existing 7.1 package. This will be replaced
+with a single unified AIX build in the Agent 2.0 timeframe, but for now
+we need to add a little bit of special-case logic to handle 7.2 with
+existing packages.
+```
+### <a name = "1.8.2">1.8.2 - 6 Jan, 2017 (625c17e3)
+
+* (HISTORY) update beaker-pe history for gem release 1.8.2 (625c17e3)
 
 * (GEM) update beaker-pe version to 1.8.2 (93ef8841)
 

data/lib/beaker-pe/install/feature_flags.rb

@@ -0,0 +1,114 @@
+module Beaker::DSL::InstallUtils
+  # This helper class encapsulates querying feature flag settings from
+  # options[:answers] which can be used to drive Beaker's install behavior
+  # around new or experimental features, typically in the PE Modules.
+  #
+  # Also handles initializing feature flag settings from environment variables
+  # for CI. In this way, flags can be pulled in without needing to munge
+  # Beaker's config file which is often handled inside of a script in Jenkins.
+  #
+  # Flags are expected to be found in a +feature_flags+ hash in the
+  # options[:answers] under the key :feature_flags.  Beaker::OptionHash should
+  # ensure that all keys end up as symbols.  If you are programatically
+  # constructing the answers, you must take care to use merge() to add
+  # elements.
+  #
+  # @example The use of the pe-modules-next package is handled by:
+  #   :answers => {
+  #     :feature_flags => {
+  #       :pe_modules_next => true
+  #     }
+  #   }
+  #
+  # All flag keys are expected to be downcased with hyphens.
+  #
+  # Environment variables may be uppercased.
+  class FeatureFlags
+    FLAGS = %w{
+      pe_modules_next
+    }.freeze
+
+    attr_reader :options
+
+    def initialize(options)
+      @options = options
+    end
+
+    # Returns the boolean state of the flag as found in options[:answers],
+    # or if not found in the answers, then it checks for an environment variable.
+    #
+    # @param String flag key
+    # @return [Boolean,nil] boolean true or false unless not found at all, then nil.
+    def flag?(flag)
+      key = canonical_key(flag)
+      state = flags[key] if flags?
+      state = environment_flag?(key) if state.nil?
+
+      case state
+      when nil then nil
+      else state.to_s == 'true'
+      end
+    end
+
+    # Updates options[:answers][:feature_flags] with any environment variables
+    # found based on FLAGS, but if and only if they are not already present.
+    #
+    # (existing :answers take precedence)
+    def register_flags!
+      answers_with_registered_flags = answers
+      answers_with_registered_flags[:feature_flags] ||= StringifyHash.new
+      new_flags = answers_with_registered_flags[:feature_flags]
+
+      FLAGS.each do |flag|
+        key = canonical_key(flag)
+        value = flag?(key)
+        if !new_flags.include?(key) && !value.nil?
+          new_flags[key] = value
+        end
+      end
+
+      options.merge!(
+        :answers => answers_with_registered_flags
+      ) if !new_flags.empty?
+
+      options
+    end
+
+    private
+
+    # Does the +feature_flags+ hash exist?
+    def flags?
+      answers? && !answers[:feature_flags].nil?
+    end
+
+    def flags
+      answers[:feature_flags] || StringifyHash.new
+    end
+
+    # Does the +answers+ hash exist?
+    def answers?
+      !options[:answers].nil?
+    end
+
+    def answers
+      options[:answers] || StringifyHash.new
+    end
+
+    def canonical_key(key)
+      key.to_s.downcase.to_sym
+    end
+
+    def environmental_keys(key)
+      [key.to_s.upcase, key.to_s.downcase]
+    end
+
+    def environment_flag?(flag)
+      value = nil
+      environmental_keys(flag).each do |f|
+        value = ENV[f] if ENV.include?(f)
+        break if !value.nil?
+      end
+      value
+    end
+  end
+end

data/lib/beaker-pe/install/pe_utils.rb

@@ -1,6 +1,7 @@
 [ 'aio_defaults', 'pe_defaults', 'puppet_utils', 'windows_utils' ].each do |lib|
     require "beaker/dsl/install_utils/#{lib}"
 end
+require 'beaker-pe/install/feature_flags'
 require "beaker-answers"
 require "timeout"
 require "json"
@@ -119,13 +120,9 @@ module Beaker
               pe_cmd += " -y"
             end
 
-            # This is a temporary workaround for PE-18516, because MEEP does not yet create a 2.0
-            # pe.conf when recovering configuration in Flanders. This will be fixed in PE-18170.
-            if opts[:type] == :upgrade && !version_is_less(host['pe_upgrade_ver'], '2017.1.0')
-              "#{pe_cmd} #{host['pe_installer_conf_setting']}"
             # If there are no answer overrides, and we are doing an upgrade from 2016.2.0,
             # we can assume there will be a valid pe.conf in /etc that we can re-use.
-            elsif opts[:answers].nil? && opts[:custom_answers].nil? && opts[:type] == :upgrade && !version_is_less(opts[:HOSTS][host.name][:pe_ver], '2016.2.0')
+            if opts[:answers].nil? && opts[:custom_answers].nil? && opts[:type] == :upgrade && !version_is_less(opts[:HOSTS][host.name][:pe_ver], '2016.2.0')
               "#{pe_cmd}"
             else
               "#{pe_cmd} #{host['pe_installer_conf_setting']}"
@@ -289,7 +286,14 @@ module Beaker
         # @param [Host] host The host to install pacakges for
         # @api private
         def deploy_frictionless_to_master(host)
-          klass = host['platform'].gsub(/-/, '_').gsub(/\./,'')
+          platform = host['platform']
+
+          # We don't have a separate AIX 7.2 build, so it is
+          # classified as 7.1 for pe_repo purposes
+          if platform == "aix-7.2-power"
+            platform = "aix-7.1-power"
+          end
+          klass = platform.gsub(/-/, '_').gsub(/\./,'')
           if host['platform'] =~ /windows/
             if host['template'] =~ /i386/
               klass = "pe_repo::platform::windows_i386"
@@ -442,6 +446,7 @@ module Beaker
                 setup_defaults_and_config_helper_on(host, master, acceptable_codes)
               else
                 prepare_host_installer_options(host)
+                register_feature_flags!(opts)
                 generate_installer_conf_file_for(host, hosts, opts)
                 on host, installer_cmd(host, opts)
                 configure_type_defaults_on(host)
@@ -611,6 +616,19 @@ module Beaker
           !version_is_less(version, MEEP_CUTOVER_VERSION)
         end
 
+        # Tests if a feature flag has been set in the answers hash provided to beaker
+        # options. Assumes a 'feature_flags' hash is present in the answers and looks for
+        # +flag+ within it.
+        #
+        # @param flag String flag to lookup
+        # @param opts Hash options hash to inspect
+        # @return true if +flag+ is true or 'true' in the feature_flags hash,
+        #   false otherwise. However, returns nil if there is no +flag+ in the
+        #   answers hash at all
+        def feature_flag?(flag, opts)
+          Beaker::DSL::InstallUtils::FeatureFlags.new(opts).flag?(flag)
+        end
+
         # Check if windows host is able to frictionlessly install puppet
         # @param [Beaker::Host] host that we are checking if it is possible to install frictionlessly to
         # @return [Boolean] true if frictionless is supported and not affected by known bugs
@@ -677,7 +695,39 @@ module Beaker
           beaker_answers_opts[:include_legacy_database_defaults] =
             opts[:type] == :upgrade && !use_meep?(host['previous_pe_ver'])
 
-          opts.merge(beaker_answers_opts)
+          modified_opts = opts.merge(beaker_answers_opts)
+
+          if feature_flag?('pe_modules_next', opts) && !modified_opts.include?(:meep_schema_version)
+            modified_opts[:meep_schema_version] = '2.0'
+          end
+
+          modified_opts
+        end
+
+        # The pe-modules-next package is being used for isolating large scale
+        # feature development of PE module code. The feature flag is a pe.conf
+        # setting 'feature_flags::pe_modules_next', which if set true will
+        # cause the installer shim to install the pe-modules-next package
+        # instead of pe-modules.
+        #
+        # This answer can be explicitly added to Beaker's cfg file by adding it
+        # to the :answers section.
+        #
+        # But it can also be picked up transparently from CI via the
+        # PE_MODULES_NEXT environment variable.  If this is set 'true', then
+        # the opts[:answers] will be set with feature_flags::pe_modules_next.
+        #
+        # Answers set in Beaker's config file will take precedence over the
+        # environment variable.
+        #
+        # NOTE: This has implications for upgrades, because upgrade testing
+        # will need the flag, but upgrades from different pe.conf schema (or no
+        # pe.conf) will need to generate a pe.conf, and that workflow is likely
+        # to happen in the installer shim.  If we simply supply a good pe.conf
+        # via beaker-answers, then we have bypassed the pe.conf generation
+        # aspect of the upgrade workflow. (See PE-19438)
+        def register_feature_flags!(opts)
+          Beaker::DSL::InstallUtils::FeatureFlags.new(opts).register_flags!
         end
 
         # Generates a Beaker Answers object for the passed *host* and creates

data/lib/beaker-pe/pe-client-tools/executable_helper.rb

@@ -75,7 +75,9 @@ module Beaker
 
             user = credentialed_dispatcher.credentials.login
             password = credentialed_dispatcher.credentials.password
-            puppet_access_on(host, 'login', {:stdin => "#{user}\n#{password}\n"})
+            args = ['login']
+            args.push "--lifetime #{lifetime}" if lifetime
+            puppet_access_on(host, *args, {:stdin => "#{user}\n#{password}\n"})
           else
 
             # this is a hack

data/lib/beaker-pe/version.rb

@@ -3,7 +3,7 @@ module Beaker
     module PE
 
       module Version
-        STRING = '1.8.2'
+        STRING = '1.9.0'
       end
 
     end

data/spec/beaker-pe/install/feature_flags_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+describe Beaker::DSL::InstallUtils::FeatureFlags do
+  let(:options) do
+    opts= Beaker::Options::Presets.new
+    opts.presets.merge(opts.env_vars)
+  end
+  let(:flags) { Beaker::DSL::InstallUtils::FeatureFlags.new(options) }
+  let(:answers) do
+    {
+      'answers' => {
+         'feature_flags' => feature_flags
+      }
+    }
+  end
+  let(:feature_flags) { {} }
+  let(:feature_flags) do
+    {
+      'pe_modules_next' => flag
+    }
+  end
+  let(:environment_flag_key) { "PE_MODULES_NEXT" }
+  let(:environment_flag_value) {}
+
+  context 'neither answers nor env' do
+    it { expect(flags.send(:answers)).to eq(StringifyHash.new) }
+    it { expect(flags.send(:answers?)).to eq(false) }
+    it { expect(flags.send(:flags)).to eq(StringifyHash.new) }
+    it { expect(flags.send(:flags?)).to eq(false) }
+    it { expect(flags.flag?('foo')).to be_nil }
+    it { expect(flags.flag?(:pe_modules_next)).to be_nil }
+    it { expect(flags.flag?('pe_modules_next')).to be_nil }
+  end
+
+  context 'answers' do
+    let(:flag) {}
+
+    before(:each) do
+      options.merge!(answers)
+    end
+
+    it { expect(flags.flag?('pe_modules_next')).to be_nil }
+
+    context 'with flag' do
+      context 'true' do
+        let(:flag) { true }
+        it { expect(flags.flag?('pe_modules_next')).to eq(true) }
+        it { expect(flags.flag?(:pe_modules_next)).to eq(true) }
+      end
+
+      context 'true as a string' do
+        let(:flag) { 'true' }
+        it { expect(flags.flag?('pe_modules_next')).to eq(true) }
+        it { expect(flags.flag?(:pe_modules_next)).to eq(true) }
+      end
+
+      context 'false' do
+        let(:flag) { false }
+        it { expect(flags.flag?('pe_modules_next')).to eq(false) }
+        it { expect(flags.flag?(:pe_modules_next)).to eq(false) }
+      end
+
+      context 'false as a string' do
+        let(:flag) { 'false' }
+        it { expect(flags.flag?('pe_modules_next')).to eq(false) }
+        it { expect(flags.flag?(:pe_modules_next)).to eq(false) }
+      end
+    end
+  end
+
+  context 'env' do
+    before(:each) do
+      allow(ENV).to receive(:[]).and_call_original
+      allow(ENV).to receive(:include?).and_call_original
+      expect(ENV).to receive(:[]).with(environment_flag_key).and_return(environment_flag_value)
+      expect(ENV).to receive(:include?).with(environment_flag_key).and_return(true)
+    end
+
+    it { expect(flags.flag?(:pe_modules_next)).to eq(nil) }
+
+    context 'with flag' do
+      context 'true' do
+        let(:environment_flag_value) { 'true' }
+        it { expect(flags.flag?('pe_modules_next')).to eq(true) }
+        it { expect(flags.flag?(:pe_modules_next)).to eq(true) }
+      end
+
+      context 'false' do
+        let(:environment_flag_value) { 'false' }
+        it { expect(flags.flag?('pe_modules_next')).to eq(false) }
+        it { expect(flags.flag?(:pe_modules_next)).to eq(false) }
+      end
+    end
+  end
+
+  context 'answers and env' do
+    before(:each) do
+      options.merge!(answers)
+      allow(ENV).to receive(:include?).and_call_original
+      expect(ENV).to_not receive(:include?).with('pe_modules_next')
+      expect(ENV).to_not receive(:include?).with('PE_MODULES_NEXT')
+    end
+
+    context 'answers true and env false' do
+      let(:flag) { 'true' }
+
+      it { expect(flags.flag?(:pe_modules_next)).to eq(true) }
+    end
+
+    context 'answers false and env true' do
+      let(:flag) { 'false' }
+
+      it { expect(flags.flag?(:pe_modules_next)).to eq(false) }
+    end
+  end
+
+  context 'registering flags' do
+    it do
+      expect(flags.register_flags!).to eq(options)
+      expect(options[:answers]).to be_nil
+    end
+
+    context 'with env variables' do
+      before(:each) do
+        allow(ENV).to receive(:[]).and_call_original
+        allow(ENV).to receive(:include?).and_call_original
+        expect(ENV).to receive(:include?).with('pe_modules_next').and_return(true)
+      end
+
+      it 'picks up a true flag from environment' do
+        expect(ENV).to receive(:[]).with('pe_modules_next').and_return('true')
+
+        flags.register_flags!
+        expect(options[:answers]).to match(
+          :feature_flags => {
+            :pe_modules_next => true
+          }
+        )
+      end
+
+      it 'picks up a false flag from environment' do
+        expect(ENV).to receive(:[]).with('pe_modules_next').and_return('false')
+
+        flags.register_flags!
+        expect(options[:answers]).to match(
+          :feature_flags => {
+            :pe_modules_next => false
+          }
+        )
+      end
+    end
+
+    context 'with answers and env variables' do
+      let(:flag) { false }
+
+      before(:each) do
+        answers['answers'][:some_other_answer] = 'value'
+        options.merge!(answers)
+        allow(ENV).to receive(:include?).and_call_original
+        expect(ENV).to_not receive(:include?).with('pe_modules_next')
+      end
+
+      it do
+        flags.register_flags!
+        expect(options[:answers]).to match(
+          :some_other_answer => 'value',
+          :feature_flags => {
+            :pe_modules_next => false
+          },
+        )
+      end
+    end
+  end
+end

data/spec/beaker-pe/install/pe_utils_spec.rb

@@ -416,6 +416,104 @@ describe ClassMixedWithDSLInstallUtils do
     end
   end
 
+  describe 'register_feature_flags!' do
+    it 'does nothing if no flag is set' do
+      expect(subject.register_feature_flags!(opts)).to eq(opts)
+      expect(opts[:answers]).to be_nil
+    end
+
+    context 'with flag set' do
+      before(:each) do
+        ENV['PE_MODULES_NEXT'] = 'true'
+      end
+
+      after(:each) do
+        ENV.delete('PE_MODULES_NEXT')
+      end
+
+      it 'updates answers' do
+        expect(subject.register_feature_flags!(opts)).to match(opts.merge({
+          :answers => {
+            :feature_flags => {
+              :pe_modules_next => true
+            }
+          }
+        }))
+      end
+
+      context 'and answer explicitly set' do
+        let(:answers) do
+          {
+            :answers => {
+              'feature_flags' => {
+                'pe_modules_next' => false
+              }
+            }
+          }
+        end
+
+        before(:each) do
+          opts.merge!(answers)
+        end
+
+        it 'keeps explicit setting' do
+          expect(subject.register_feature_flags!(opts)).to match(opts.merge(answers))
+        end
+      end
+    end
+  end
+
+  describe 'feature_flag?' do
+
+    context 'without :answers' do
+      it 'is nil for pe_modules_next' do
+        expect(subject.feature_flag?('pe_modules_next', opts)).to eq(nil)
+        expect(subject.feature_flag?(:pe_modules_next, opts)).to eq(nil)
+      end
+    end
+
+    context 'with :answers but no flag' do
+      before(:each) do
+        opts[:answers] = {}
+      end
+
+      it 'is nil for pe_modules_next' do
+        expect(subject.feature_flag?('pe_modules_next', opts)).to eq(nil)
+        expect(subject.feature_flag?(:pe_modules_next, opts)).to eq(nil)
+      end
+    end
+
+    context 'with answers set' do
+      let(:options) do
+        opts.merge(
+          :answers => {
+            'feature_flags' => {
+              'pe_modules_next' => flag
+            }
+          }
+        )
+      end
+
+      context 'false' do
+        let(:flag) { false }
+        it { expect(subject.feature_flag?('pe_modules_next', options)).to eq(false) }
+        it { expect(subject.feature_flag?(:pe_modules_next, options)).to eq(false) }
+      end
+
+      context 'true' do
+        let(:flag) { true }
+        it { expect(subject.feature_flag?('pe_modules_next', options)).to eq(true) }
+        it { expect(subject.feature_flag?(:pe_modules_next, options)).to eq(true) }
+
+        context 'as string' do
+          let(:flag) { 'true' }
+          it { expect(subject.feature_flag?('pe_modules_next', options)).to eq(true) }
+          it { expect(subject.feature_flag?(:pe_modules_next, options)).to eq(true) }
+        end
+      end
+    end
+  end
+
   describe 'setup_beaker_answers_opts' do
     let(:opts) { {} }
     let(:host) { hosts.first }
@@ -445,6 +543,28 @@ describe ClassMixedWithDSLInstallUtils do
         )
       end
 
+      context 'with pe-modules-next' do
+        let(:options) do
+          opts.merge(
+            :answers => {
+              :feature_flags => {
+                :pe_modules_next => true
+              }
+            }
+          )
+        end
+
+        it 'adds meep_schema_version' do
+          expect(subject.setup_beaker_answers_opts(host, options)).to eq(
+            options.merge(
+              :format => :hiera,
+              :include_legacy_database_defaults => false,
+              :meep_schema_version => '2.0',
+            )
+          )
+        end
+      end
+
       context 'when upgrading' do
         let(:opts) { { :type => :upgrade } }
 

data/spec/beaker-pe/pe-client-tools/executable_helper_spec.rb

@@ -1,5 +1,6 @@
 require 'spec_helper'
 require 'beaker'
+require 'scooter'
 
 class MixedWithExecutableHelper
   include Beaker::DSL::PEClientTools::ExecutableHelper
@@ -9,7 +10,7 @@ describe MixedWithExecutableHelper do
 
   let(:method_name)   { "puppet_#{tool}_on"}
 
-  shared_examples 'pe-client-tool'do
+  shared_examples 'pe-client-tool' do
 
     it 'has a method to execute the tool' do
       expect(subject.respond_to?(method_name)).not_to be(false)
@@ -55,4 +56,28 @@ describe MixedWithExecutableHelper do
   it 'has a method to login with puppet access' do
     expect(subject.respond_to?('login_with_puppet_access_on')).not_to be(false)
   end
-end
+
+  context 'puppet access login with lifetime parameter' do
+    let(:logger) {Beaker::Logger.new}
+    let(:test_host) {Beaker::Host.create('my_super_host',
+                                         {:roles => ['master', 'agent'],
+                                          :platform => 'linux',
+                                          :type => 'pe'},
+                                          make_opts)}
+    let(:username) {'T'}
+    let(:password) {'Swift'}
+    let(:credentials) {{:login => username, :password => password}}
+    let(:test_dispatcher) {Scooter::HttpDispatchers::ConsoleDispatcher.new('my_super_host', credentials)}
+
+    before do
+      allow(logger).to receive(:debug) { true }
+      expect(test_dispatcher).to be_kind_of(Scooter::HttpDispatchers::ConsoleDispatcher)
+      expect(test_host).to be_kind_of(Beaker::Host)
+      expect(test_host).to receive(:exec)
+    end
+
+    it 'accepts correct value' do
+      expect{subject.login_with_puppet_access_on(test_host, test_dispatcher, {:lifetime => '5d'})}.not_to raise_error
+    end
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: beaker-pe
 version: !ruby/object:Gem::Version
-  version: 1.8.2
+  version: 1.9.0
 platform: ruby
 authors:
 - Puppetlabs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-01-06 00:00:00.000000000 Z
+date: 2017-02-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -190,6 +190,7 @@ files:
 - bin/beaker-template
 - docs/how_to/install_puppet_enterprise.md
 - lib/beaker-pe.rb
+- lib/beaker-pe/install/feature_flags.rb
 - lib/beaker-pe/install/pe_utils.rb
 - lib/beaker-pe/options/pe_version_scraper.rb
 - lib/beaker-pe/pe-client-tools/config_file_helper.rb
@@ -197,6 +198,7 @@ files:
 - lib/beaker-pe/pe-client-tools/install_helper.rb
 - lib/beaker-pe/version.rb
 - spec/beaker-pe/helpers_spec.rb
+- spec/beaker-pe/install/feature_flags_spec.rb
 - spec/beaker-pe/install/pe_utils_spec.rb
 - spec/beaker-pe/options/pe_version_scaper_spec.rb
 - spec/beaker-pe/pe-client-tools/config_file_helper_spec.rb