beaker-answers 0.4.3 → 0.5.0

data/spec/beaker-answers/beaker-answers_spec.rb

@@ -29,6 +29,36 @@ describe BeakerAnswers do
     end
   end
 
+  context 'when we are upgrading to a version > 3.8' do
+    supported_general_upgrade_versions = [ '2015.1.0',
+                                           '2016.1.0',
+                                           '2016.2.1']
+    supported_general_upgrade_versions.each do |version|
+      it "still creates the full install answers" do
+        @ver = version
+        options[:type] = :upgrade
+        expect( answers ).to be_a_kind_of BeakerAnswers::Answers
+        expect( answers ).to_not be_a_kind_of BeakerAnswers::Upgrade
+      end
+    end
+  end
+
+  it 'generates upgrade38 answers when type is upgrade and the version 3.8' do
+    @ver = '3.8.3'
+    options[:type] = :upgrade
+    expect( answers ).to be_a_kind_of BeakerAnswers::Upgrade38
+  end
+
+  it 'generates 2016.2 answers for 2016.2 hosts' do
+    @ver = '2016.2.0'
+    expect( answers ).to be_a_kind_of BeakerAnswers::Version20162
+  end
+
+  it 'generates 2016.1 answers for 2016.1 hosts' do
+    @ver = '2016.1.0'
+    expect( answers ).to be_a_kind_of BeakerAnswers::Version20161
+  end
+
   it 'generates 2015.3 answers for 2015.3 hosts' do
     @ver = '2015.3.0'
     expect( answers ).to be_a_kind_of BeakerAnswers::Version20153
@@ -357,27 +387,6 @@ describe BeakerAnswers::Version20153 do
   end
 end
 
-describe BeakerAnswers::Version20162 do
-  let( :options )     { StringifyHash.new }
-  let( :basic_hosts ) { make_hosts( {'pe_ver' => @ver } ) }
-  let( :hosts ) { basic_hosts[0]['roles'] = ['master', 'agent']
-                  basic_hosts[1]['roles'] = ['dashboard', 'agent']
-                  basic_hosts[2]['roles'] = ['database', 'agent']
-                  basic_hosts }
-  let( :answers )     { BeakerAnswers::Answers.create(@ver, hosts, options) }
-  let( :upgrade_answers )     { BeakerAnswers::Answers.create(@ver, hosts, options.merge( {:type => :upgrade}) ) }
-
-  before :each do
-    @ver = '2016.2'
-    @answers = answers.answers
-  end
-
-  it 'should add orchestrator database answers to console' do
-    expect( @answers['vm2'][:q_orchestrator_database_name] ).to be === 'pe-orchestrator'
-    expect( @answers['vm2'][:q_orchestrator_database_user] ).to be === 'Orc3Str8R'
-  end
-end
-
 describe BeakerAnswers::Version32 do
   let( :options )     { StringifyHash.new }
   let( :basic_hosts ) { make_hosts( {'pe_ver' => @ver } ) }
@@ -546,12 +555,12 @@ describe 'Customization' do
                         basic_hosts }
   let( :answers )     { BeakerAnswers::Answers.create(@ver, hosts, options) }
 
-  def test_answer_customization(answer_key, value_to_set)
+  def test_answer_customization(answer_key, value_to_set, expected_value = value_to_set)
     @ver = '3.0'
     options[:answers] ||= StringifyHash.new
     options[:answers][answer_key] = value_to_set
     host_answers = answers.answers['vm1']
-    expect( host_answers[answer_key] ).to be === value_to_set
+    expect( host_answers[answer_key] ).to be === expected_value
   end
 
   it 'sets :q_puppetdb_hostname' do
@@ -563,7 +572,7 @@ describe 'Customization' do
   end
 
   it 'sets :q_puppetdb_database_password' do
-    test_answer_customization(:q_puppetdb_database_password, 'q_puppetdb_database_password_custom03')
+    test_answer_customization(:q_puppetdb_database_password, 'q_puppetdb_database_password_custom03', "'q_puppetdb_database_password_custom03'")
   end
 
   it 'sets :q_puppet_enterpriseconsole_auth_database_password' do

data/spec/beaker-answers/helpers_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe '#flatten_keys_to_joined_string' do
+  it 'flattens a deep hash into a shallow one' do
+    deep = {'a' => {'b' => {'c' => {'d' => 'e'}}}}
+    shallow = flatten_keys_to_joined_string(deep)
+    expect(shallow).to include({'a::b::c::d' => 'e'})
+  end
+
+  it 'handles duplicate keys' do
+    deep = {'a' => {'a' => {'a' => {'a' => 'a'}}}}
+    shallow = flatten_keys_to_joined_string(deep)
+    expect(shallow).to include({'a::a::a::a' => 'a'})
+  end
+
+  it 'creates keys for each grandchilds values' do
+    deep = {'a' => {'b' => 'c', 'd' => 'e'}}
+    shallow = flatten_keys_to_joined_string(deep)
+    expect(shallow).to include({'a::b' => 'c'})
+    expect(shallow).to include({'a::d' => 'e'})
+  end
+
+  it 'does not change keys with ::' do
+    deep = {'a::b' => {'c::d' => 'e'}}
+    shallow = flatten_keys_to_joined_string(deep)
+    expect(shallow).to include({'a::b::c::d' => 'e'})
+  end
+
+  it 'does not blow up on an empty hash' do
+    deep = {}
+    shallow = flatten_keys_to_joined_string(deep)
+    expect(shallow).to include({})
+  end
+
+  it 'converts key symbols to strings' do
+    deep = {:a => 'b'}
+    shallow = flatten_keys_to_joined_string(deep)
+    expect(shallow).to include({'a' => 'b'})
+  end
+
+  it 'converts nested key symbols to strings' do
+    deep = {:a => {:b => 'c'}}
+    shallow = flatten_keys_to_joined_string(deep)
+    expect(shallow).to include({'a::b' => 'c'})
+  end
+end

data/spec/beaker-answers/upgrade_spec.rb

@@ -0,0 +1,135 @@
+describe BeakerAnswers::Upgrade do
+  let( :options )     { StringifyHash.new }
+  let( :basic_hosts ) { make_hosts( {'pe_ver' => @ver } ) }
+  let( :hosts ) { basic_hosts[0]['roles'] = ['master', 'agent']
+                  basic_hosts[1]['roles'] = ['dashboard', 'agent']
+                  basic_hosts[2]['roles'] = ['database', 'agent']
+                  basic_hosts }
+  let( :answers )     { BeakerAnswers::Upgrade.new(@ver, hosts, options.merge({:type => :upgrade}) ) }
+
+  before :each do
+    @ver = '3.8'
+    @answers = answers.answers
+  end
+
+  context '#generate_answers' do
+    it 'only adds the default yes for each host' do
+      host_answers = answers.generate_answers
+      host_answers.each do |host, host_answer|
+        expect(host_answer).to eq({:q_install => 'y'})
+        expect(host_answer.length).to eq(1)
+      end
+    end
+  end
+
+end
+
+describe BeakerAnswers::Upgrade38 do
+
+  let( :options )     { StringifyHash.new }
+  let( :basic_hosts ) { make_hosts( {'pe_ver' => @ver } ) }
+  let( :hosts ) { basic_hosts[0]['roles'] = ['master', 'agent']
+                  basic_hosts[1]['roles'] = ['dashboard', 'agent']
+                  basic_hosts[2]['roles'] = ['database', 'agent']
+                  basic_hosts }
+  let( :answers )     { BeakerAnswers::Answers.create(@ver, hosts, options.merge({:type => :upgrade}) ) }
+
+  before :each do
+    @ver = '3.8'
+    @answers = answers.answers
+  end
+
+  context 'when no special answers are provided' do
+    it "the master should have only three keys" do
+      answer = @answers['vm1']
+      expect(answer[:q_install]).to eq('y')
+      expect(answer[:q_enable_future_parser]).to eq('y')
+      expect(answer[:q_exit_for_nc_migrate]).to eq('n')
+      expect(answer.length).to eq(3)
+    end
+
+    it 'the dashboard should have 19 keys provided' do
+      answer = @answers['vm2']
+
+      expect(answer[:q_install]).to eq('y')
+      expect(answer[:q_enable_future_parser]).to eq('y')
+      expect(answer[:q_exit_for_nc_migrate]).to eq('n')
+      expect(answer[:q_rbac_database_name]).to eq('pe-rbac')
+      expect(answer[:q_rbac_database_user]).to eq('RbhNBklm')
+      expect(answer[:q_rbac_database_password]).to eq("'~!@#$%^*-/ aZ'")
+      expect(answer[:q_activity_database_user]).to eq('adsfglkj')
+      expect(answer[:q_activity_database_name]).to eq('pe-activity')
+      expect(answer[:q_activity_database_password]).to eq("'~!@#$%^*-/ aZ'")
+      expect(answer[:q_classifier_database_name]).to eq('pe-classifier')
+      expect(answer[:q_classifier_database_user]).to eq('DFGhjlkj')
+      expect(answer[:q_classifier_database_password]).to eq("'~!@#$%^*-/ aZ'")
+      expect(answer[:q_puppetdb_database_name]).to eq('pe-puppetdb')
+      expect(answer[:q_puppetdb_database_user]).to eq('mYpdBu3r')
+      expect(answer[:q_puppetdb_database_password]).to eq("'~!@#$%^*-/ aZ'")
+      expect(answer[:q_puppet_enterpriseconsole_auth_password]).to eq("'~!@#$%^*-/ aZ'")
+      expect(answer[:q_puppetdb_port]).to eq(8081)
+      expect(answer[:q_install]).to eq('y')
+      expect(answer[:q_enable_future_parser]).to eq('y')
+      expect(answer[:q_exit_for_nc_migrate]).to eq('n')
+      expect(answer.length).to eq(19)
+    end
+
+    it 'the database should have 13 keys provided' do
+      answer = @answers['vm3']
+      expect(answer[:q_enable_future_parser]).to eq('y')
+      expect(answer[:q_exit_for_nc_migrate]).to eq('n')
+      expect(answer[:q_rbac_database_name]).to eq('pe-rbac')
+      expect(answer[:q_rbac_database_user]).to eq('RbhNBklm')
+      expect(answer[:q_rbac_database_password]).to eq("'~!@#$%^*-/ aZ'")
+      expect(answer[:q_activity_database_user]).to eq('adsfglkj')
+      expect(answer[:q_activity_database_name]).to eq('pe-activity')
+      expect(answer[:q_activity_database_password]).to eq("'~!@#$%^*-/ aZ'")
+      expect(answer[:q_classifier_database_name]).to eq('pe-classifier')
+      expect(answer[:q_classifier_database_user]).to eq('DFGhjlkj')
+      expect(answer[:q_classifier_database_password]).to eq("'~!@#$%^*-/ aZ'")
+      expect(answer[:q_install]).to eq('y')
+      expect(answer[:q_enable_future_parser]).to eq('y')
+      expect(answer[:q_exit_for_nc_migrate]).to eq('n')
+      expect(answer.length).to eq(13)
+    end
+  end
+
+  context 'when we set :q_enable_future_parser in global options' do
+    let( :options ) {
+      options = StringifyHash.new
+      options[:answers] = { :q_enable_future_parser => 'thefutureparser!!!'}
+      options
+    }
+    it 'sets that parser option from the global options' do
+      @answers.each do |vmname, answer|
+        expect(answer[:q_enable_future_parser]).to eq('thefutureparser!!!')
+      end
+    end
+
+  context 'when per host custom answers are provided for the master and dashboard' do
+    let( :hosts ) { basic_hosts[0]['roles'] = ['master', 'agent']
+                    basic_hosts[0][:custom_answers] = { :q_custom0 => '0LOOK' }
+                    basic_hosts[1]['roles'] = ['dashboard', 'agent']
+                    basic_hosts[1][:custom_answers] = { :q_custom1 => 'LOOKLOOK',
+                                                        :q_custom2 => "LOOK3"}
+                    basic_hosts[2]['roles'] = ['database', 'agent']
+                    basic_hosts }
+
+    it 'adds those custom answers to the master' do
+      expect( @answers['vm1'][:q_custom0] ).to be === '0LOOK'
+      expect(@answers['vm1'].length).to eq(4)
+    end
+
+    it 'adds custom answers to the dashboard' do
+      expect( @answers['vm2'][:q_custom1] ).to be === 'LOOKLOOK'
+      expect( @answers['vm2'][:q_custom2] ).to be === 'LOOK3'
+      expect( @answers['vm2'].length).to eq(21)
+    end
+
+    it 'does not add custom answers for the database' do
+      expect(@answers['vm3'].length).to eq(13)
+    end
+  end
+
+  end
+end

data/spec/beaker-answers/versions/version20162_spec.rb

@@ -0,0 +1,366 @@
+require 'spec_helper'
+require 'json'
+
+describe BeakerAnswers::Version20162 do
+  let( :ver )         { '2016.2.0' }
+  let( :options )     { StringifyHash.new }
+  let( :basic_hosts ) { make_hosts( {'pe_ver' => ver } ) }
+  let( :hosts ) { basic_hosts[0]['roles'] = ['master', 'agent']
+                  basic_hosts[1]['roles'] = ['dashboard', 'agent']
+                  basic_hosts[2]['roles'] = ['database', 'agent']
+                  basic_hosts }
+  let( :answers )     { BeakerAnswers::Answers.create(ver, hosts, options) }
+  let( :answer_hash ) { answers.answers }
+
+  it 'adds orchestrator database answers to console' do
+    expect( answer_hash['vm2'][:q_orchestrator_database_name] ).to be === 'pe-orchestrator'
+    expect( answer_hash['vm2'][:q_orchestrator_database_user] ).to be === 'Orc3Str8R'
+  end
+
+  it 'generates valid answers if #answer_string is called' do
+    expect( answers.answer_string(basic_hosts[2]) ).to match(/q_orchestrator_database_name=pe-orchestrator/)
+  end
+
+  context 'when generating a hiera config' do
+    let( :options )      { { :format => 'hiera' } }
+    let( :answer_hiera ) { answers.answer_hiera }
+    let( :default_password ) { '~!@#$%^*-/ aZ' }
+    let( :gold_role_answers ) do
+      {
+        "console_admin_password" => default_password,
+        "puppet_enterprise::use_application_services" => true,
+        "puppet_enterprise::certificate_authority_host" => basic_hosts[0].hostname,
+        "puppet_enterprise::puppet_master_host" => basic_hosts[0].hostname,
+        "puppet_enterprise::console_host" => basic_hosts[1].hostname,
+        "puppet_enterprise::puppetdb_host" => basic_hosts[2].hostname,
+        "puppet_enterprise::database_host" => basic_hosts[2].hostname,
+        "puppet_enterprise::pcp_broker_host" => basic_hosts[0].hostname,
+        "puppet_enterprise::mcollective_middleware_hosts" => [basic_hosts[0].hostname],
+      }
+    end
+    let( :gold_db_answers ) do
+      {
+        "puppet_enterprise::activity_database_user" => 'adsfglkj',
+        "puppet_enterprise::classifier_database_user" => 'DFGhjlkj',
+        "puppet_enterprise::orchestrator_database_user" => 'Orc3Str8R',
+        "puppet_enterprise::puppetdb_database_user" => 'mYpdBu3r',
+        "puppet_enterprise::rbac_database_user" => 'RbhNBklm',
+      }
+    end
+    let( :gold_db_password_answers ) do
+      {
+        "puppet_enterprise::activity_database_password" => default_password,
+        "puppet_enterprise::classifier_database_password" => default_password,
+        "puppet_enterprise::orchestrator_database_password" => default_password,
+        "puppet_enterprise::puppetdb_database_password" => default_password,
+        "puppet_enterprise::rbac_database_password" => default_password,
+      }
+    end
+    # This is a set of database parameters specified in host.cfg :answers
+    # (for an external postgres, for instance)
+    let( :overridden_database_parameters ) do
+      {
+        "puppet_enterprise::activity_database_name" => 'custom-activity',
+        "puppet_enterprise::activity_database_user" => 'custom-activity-user',
+        "puppet_enterprise::classifier_database_name" => 'custom-classifier',
+        "puppet_enterprise::classifier_database_user" => 'custom-classifier-user',
+        "puppet_enterprise::orchestrator_database_name" => 'custom-orchestrator',
+        "puppet_enterprise::orchestrator_database_user" => 'custom-orchestrator-user',
+        "puppet_enterprise::puppetdb_database_name" => 'custom-puppetdb',
+        "puppet_enterprise::puppetdb_database_user" => 'custom-puppetdb-user',
+        "puppet_enterprise::rbac_database_name" => 'custom-rbac',
+        "puppet_enterprise::rbac_database_user" => 'custom-rbac-user',
+        "puppet_enterprise::activity_database_password" => 'custom-activity-password',
+        "puppet_enterprise::classifier_database_password" => 'custom-classifier-password',
+        "puppet_enterprise::orchestrator_database_password" => 'custom-orchestrator-password',
+        "puppet_enterprise::puppetdb_database_password" => 'custom-puppetdb-password',
+        "puppet_enterprise::rbac_database_password" => 'custom-rbac-password',
+      }
+    end
+
+    it 'should not have nil keys or values' do
+      answer_hash.each_pair { |k, v|
+        expect([k, v]).not_to include(nil)
+      }
+    end
+
+    it 'has the just the role and values for default install' do
+      expect(answer_hash).to eq(
+        gold_role_answers
+      )
+    end
+
+    context 'when include_legacy_database_defaults' do
+      context 'is false' do
+        let(:options) do
+          {
+            :format => 'hiera',
+            :include_legacy_database_defaults => false,
+          }
+        end
+
+        it 'has only the role values' do
+          expect(answer_hash).to eq(gold_role_answers)
+        end
+
+        it 'also includes any explicitly added database parameters' do
+          options.merge!(:answers => overridden_database_parameters)
+          expect(answer_hash).to eq(
+            gold_role_answers
+              .merge(overridden_database_parameters)
+          )
+        end
+      end
+
+      context 'is true' do
+        let(:options) do
+          {
+            :format => 'hiera',
+            :include_legacy_database_defaults => true,
+          }
+        end
+
+        it 'has the role values and database defaults' do
+          expect(answer_hash).to eq(
+            gold_role_answers
+              .merge(gold_db_answers)
+          )
+        end
+
+        it 'overrides defaults with explicitly added database parameters' do
+          options.merge!(:answers => overridden_database_parameters)
+          expect(answer_hash).to eq(
+            gold_role_answers
+              .merge(overridden_database_parameters)
+          )
+        end
+      end
+    end
+
+    it 'generates valid json if #answer_hiera is called' do
+      expect(answer_hiera).not_to be_empty
+      expect { JSON.load(answer_hiera) }.not_to raise_error
+      expect(answer_hiera).to match "puppet_enterprise::puppet_master_host.*:.*#{basic_hosts[0].hostname}"
+    end
+
+    context 'with legacy answers present' do
+      let(:string_answer) { { 'q_puppet_enterpriseconsole_auth_password' => 'password' } }
+      let(:symbol_answer) { { :q_puppet_enterpriseconsole_auth_password => 'password' } }
+      let(:answers) { BeakerAnswers::Answers.create(ver, hosts, options) }
+
+      context 'when key is a string' do
+        let(:options) { { :format => 'hiera' }.merge(:answers => string_answer) }
+
+        it 'raises a TypeError' do
+          expect { answers.answers }.to raise_error(TypeError, /q_ answers are not supported/)
+        end
+      end
+
+      context 'when key is a symbol' do
+        let(:options) { { :format => 'hiera' }.merge(:answers => symbol_answer) }
+
+        it 'raises a TypeError' do
+          expect { answers.answers }.to raise_error(TypeError, /q_ answers are not supported/)
+        end
+      end
+    end
+
+    context 'when overriding answers' do
+      let( :options ) do
+        {
+          :format  => 'hiera',
+          :answers => {
+            'puppet_enterprise' =>  { 'certificate_authority_host' => 'enterpriseca.vm' },
+            'puppet_enterprise::console_host' => 'enterpriseconsole.vm',
+            'console_admin_password' => 'testing123',
+          }
+        }
+      end
+
+      it 'overrides the defaults when multi-level hash :answers are given' do
+        expect(answer_hash["puppet_enterprise::certificate_authority_host"]).to be === 'enterpriseca.vm'
+      end
+
+      it 'overrides the defaults when a :: delimited key is given' do
+        expect(answer_hash["puppet_enterprise::console_host"]).to be === 'enterpriseconsole.vm'
+      end
+
+      it 'overrides the console_admin_password default' do
+        expect(answer_hash["console_admin_password"]).to be === 'testing123'
+      end
+
+      it 'does not add a duplicate key to the hash' do
+        expect(answer_hash.length).to eq(gold_role_answers.length)
+      end
+    end
+
+    context 'when overriding answers using symbolic keys' do
+      let( :options ) do
+        {
+          :format  => 'hiera',
+          :answers => {
+            :puppet_enterprise =>  {
+              :certificate_authority_host => 'enterpriseca.vm',
+              :console_host => 'enterpriseconsole.vm',
+            },
+            :console_admin_password => 'testing123',
+          }
+        }
+      end
+
+      it 'overrides the defaults when multi-level hash :answers are given' do
+        expect(answer_hash["puppet_enterprise::certificate_authority_host"]).to be === 'enterpriseca.vm'
+      end
+
+      it 'overrides the defaults when a :: delimited key is given' do
+        expect(answer_hash["puppet_enterprise::console_host"]).to be === 'enterpriseconsole.vm'
+      end
+
+      it 'overrides the console_admin_password default' do
+        expect(answer_hash["console_admin_password"]).to be === 'testing123'
+      end
+
+      it 'does not add duplicate keys to the hash' do
+        expect(answer_hash.length).to eq(gold_role_answers.length)
+      end
+    end
+  end
+
+  # This spec is just providing a baseline for :bash answer generation/regression.
+  # This and bash answer generation in 2016.2.0+ should be dropped once we've cutover.
+  it 'continues to provide same set of :bash answers' do
+    expect(answer_hash).to eq({
+      "vm1" => {
+        :q_install=>"y",
+        :q_vendor_packages_install=>"y",
+        :q_puppetagent_install=>"y",
+        :q_verify_packages=>"y",
+        :q_puppet_symlinks_install=>"y",
+        :q_puppetagent_certname=>"vm1",
+        :q_puppetmaster_install=>"y",
+        :q_all_in_one_install=>"n",
+        :q_puppet_enterpriseconsole_install=>"n",
+        :q_puppetdb_install=>"n",
+        :q_database_install=>"n",
+        :q_puppetagent_server=>"vm1",
+        :q_puppetdb_hostname=>"vm3",
+        :q_puppetdb_port=>8081,
+        :q_puppetmaster_dnsaltnames=>"vm1,ip.address.for.vm1,puppet",
+        :q_puppetmaster_enterpriseconsole_hostname=>"vm2",
+        :q_puppetmaster_enterpriseconsole_port=>443,
+        :q_puppetmaster_certname=>"vm1",
+        :q_pe_check_for_updates=>"n",
+        :q_exit_for_nc_migrate=>"n",
+        :q_enable_future_parser=>"n",
+        :q_update_server_host=>"vm1",
+        :q_install_update_server=>"y",
+        :q_orchestrator_database_name=>"pe-orchestrator",
+        :q_orchestrator_database_user=>"Orc3Str8R",
+        :q_orchestrator_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_database_host=>"vm3",
+        :q_database_port=>5432,
+        :q_use_application_services=>"y"
+      },
+      "vm2" => {
+        :q_install=>"y",
+        :q_vendor_packages_install=>"y",
+        :q_puppetagent_install=>"y",
+        :q_verify_packages=>"y",
+        :q_puppet_symlinks_install=>"y",
+        :q_puppetagent_certname=>"vm2",
+        :q_puppetmaster_install=>"n",
+        :q_all_in_one_install=>"n",
+        :q_puppet_enterpriseconsole_install=>"y",
+        :q_puppetdb_install=>"n",
+        :q_database_install=>"n",
+        :q_puppetagent_server=>"vm1",
+        :q_puppetdb_hostname=>"vm3",
+        :q_puppetdb_port=>8081,
+        :q_puppetdb_database_name=>"pe-puppetdb",
+        :q_puppetdb_database_user=>"mYpdBu3r",
+        :q_puppetdb_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_puppet_enterpriseconsole_auth_database_name=>"console_auth",
+        :q_puppet_enterpriseconsole_auth_database_user=>"mYu7hu3r",
+        :q_puppet_enterpriseconsole_auth_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_puppet_enterpriseconsole_database_name=>"console",
+        :q_puppet_enterpriseconsole_database_user=>"mYc0nS03u3r",
+        :q_puppet_enterpriseconsole_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_database_host=>"vm3",
+        :q_database_port=>5432,
+        :q_pe_database=>"y",
+        :q_puppet_enterpriseconsole_inventory_hostname=>"vm2",
+        :q_puppet_enterpriseconsole_inventory_certname=>"vm2",
+        :q_puppet_enterpriseconsole_inventory_dnsaltnames=>"vm2",
+        :q_puppet_enterpriseconsole_inventory_port=>8140,
+        :q_puppet_enterpriseconsole_master_hostname=>"vm1",
+        :q_puppet_enterpriseconsole_auth_user_email=>"'admin@example.com'",
+        :q_puppet_enterpriseconsole_auth_password=>"'~!@\#$%^*-/ aZ'",
+        :q_puppet_enterpriseconsole_httpd_port=>443,
+        :q_puppet_enterpriseconsole_smtp_host=>"'vm2'",
+        :q_puppet_enterpriseconsole_smtp_use_tls=>"'n'",
+        :q_puppet_enterpriseconsole_smtp_port=>"'25'",
+        :q_puppetmaster_certname=>"vm1",
+        :q_pe_check_for_updates=>"n",
+        :q_classifier_database_user=>"DFGhjlkj",
+        :q_classifier_database_name=>"pe-classifier",
+        :q_classifier_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_activity_database_user=>"adsfglkj",
+        :q_activity_database_name=>"pe-activity",
+        :q_activity_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_rbac_database_user=>"RbhNBklm",
+        :q_rbac_database_name=>"pe-rbac",
+        :q_rbac_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_exit_for_nc_migrate=>"n",
+        :q_enable_future_parser=>"n",
+        :q_update_server_host=>"vm1",
+        :q_use_application_services=>"y",
+        :q_orchestrator_database_name=>"pe-orchestrator",
+        :q_orchestrator_database_user=>"Orc3Str8R"
+      },
+      "vm3" => {
+        :q_install=>"y",
+        :q_vendor_packages_install=>"y",
+        :q_puppetagent_install=>"y",
+        :q_verify_packages=>"y",
+        :q_puppet_symlinks_install=>"y",
+        :q_puppetagent_certname=>"vm3",
+        :q_puppetmaster_install=>"n",
+        :q_all_in_one_install=>"n",
+        :q_puppet_enterpriseconsole_install=>"n",
+        :q_puppetdb_install=>"y",
+        :q_database_install=>"y",
+        :q_puppetagent_server=>"vm1",
+        :q_puppetmaster_certname=>"vm1",
+        :q_database_root_password=>"'=ZYdjiP3jCwV5eo9s1MBd'",
+        :q_database_root_user=>"pe-postgres",
+        :q_puppetdb_database_name=>"pe-puppetdb",
+        :q_puppetdb_database_user=>"mYpdBu3r",
+        :q_puppetdb_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_puppet_enterpriseconsole_auth_database_name=>"console_auth",
+        :q_puppet_enterpriseconsole_auth_database_user=>"mYu7hu3r",
+        :q_puppet_enterpriseconsole_auth_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_puppet_enterpriseconsole_database_name=>"console",
+        :q_puppet_enterpriseconsole_database_user=>"mYc0nS03u3r",
+        :q_puppet_enterpriseconsole_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_database_host=>"vm3",
+        :q_database_port=>5432,
+        :q_classifier_database_user=>"DFGhjlkj",
+        :q_classifier_database_name=>"pe-classifier",
+        :q_classifier_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_activity_database_user=>"adsfglkj",
+        :q_activity_database_name=>"pe-activity",
+        :q_activity_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_rbac_database_user=>"RbhNBklm",
+        :q_rbac_database_name=>"pe-rbac",
+        :q_rbac_database_password=>"'~!@\#$%^*-/ aZ'",
+        :q_exit_for_nc_migrate=>"n",
+        :q_enable_future_parser=>"n",
+        :q_update_server_host=>"vm1",
+        :q_orchestrator_database_name=>"pe-orchestrator",
+        :q_orchestrator_database_user=>"Orc3Str8R",
+        :q_orchestrator_database_password=>"'~!@\#$%^*-/ aZ'"
+      },
+    })
+  end
+
+end