require 'spec_helper'
class ClassMixedWithDSLInstallUtils
include Beaker::DSL::InstallUtils
include Beaker::DSL::InstallUtils::FOSSUtils
include Beaker::DSL::Wrappers
include Beaker::DSL::Helpers
include Beaker::DSL::Structure
include Beaker::DSL::Roles
include Beaker::DSL::Patterns
def logger
@logger ||= RSpec::Mocks::Double.new('logger').as_null_object
end
end
describe ClassMixedWithDSLInstallUtils do
let(:metadata) { @metadata ||= {} }
let(:presets) { Beaker::Options::Presets.new }
let(:opts) { presets.presets.merge(presets.env_vars).merge({ type: 'foss' }) }
let(:basic_hosts) do
make_hosts({ pe_ver: '3.0',
platform: 'linux',
roles: ['agent'],
type: 'foss', }, 4)
end
let(:hosts) do
basic_hosts[0][:roles] = %w[master database dashboard]
basic_hosts[1][:platform] = 'windows'
basic_hosts[2][:platform] = 'osx-10.9-x86_64'
basic_hosts[3][:platform] = 'eos'
basic_hosts
end
let(:hosts_sorted) { [hosts[1], hosts[0], hosts[2], hosts[3]] }
let(:winhost) do
make_host('winhost', { platform: Beaker::Platform.new('windows-2008r2-64'),
pe_ver: '3.0',
working_dir: '/tmp',
type: 'foss',
is_cygwin: true, })
end
let(:winhost_non_cygwin) do
make_host('winhost_non_cygwin', { platform: 'windows',
pe_ver: '3.0',
working_dir: '/tmp',
type: 'foss',
is_cygwin: 'false', })
end
let(:machost) do
make_host('machost', { platform: 'osx-10.9-x86_64',
pe_ver: '3.0',
type: 'foss',
working_dir: '/tmp', })
end
let(:freebsdhost12) do
make_host('freebsdhost12', { platform: 'freebsd-12-amd64',
pe_ver: '3.0',
working_dir: '/tmp', })
end
let(:freebsdhost13) do
make_host('freebsdhost13', { platform: 'freebsd-13-amd64',
pe_ver: '3.0',
working_dir: '/tmp', })
end
let(:unixhost) do
make_host('unixhost', { platform: 'linux',
pe_ver: '3.0',
working_dir: '/tmp',
type: 'foss',
dist: 'puppet-enterprise-3.1.0-rc0-230-g36c9e5c-debian-7-i386', })
end
let(:eoshost) do
make_host('eoshost', { platform: 'eos',
pe_ver: '3.0',
working_dir: '/tmp',
type: 'foss',
dist: 'puppet-enterprise-3.7.1-rc0-78-gffc958f-eos-4-i386', })
end
let(:el6hostaio) do
make_host('el6hostaio', { platform: Beaker::Platform.new('el-6-i386'),
pe_ver: '3.0',
working_dir: '/tmp',
type: 'aio',
dist: 'puppet-enterprise-3.1.0-rc0-230-g36c9e5c-centos-6-i386', })
end
let(:el6hostfoss) do
make_host('el6hostfoss', { platform: Beaker::Platform.new('el-6-i386'),
pe_ver: '3.0',
working_dir: '/tmp',
type: 'foss',
dist: 'puppet-enterprise-3.1.0-rc0-230-g36c9e5c-centos-6-i386', })
end
let(:win_temp) { 'C:\\Windows\\Temp' }
context '#sanitize_opts' do
let(:opts) do
{
win_download_url: nil,
dev_builds_url: '',
release_yum_repo_url: 'https://apt.customserver.net/apt',
}
end
it 'honors any custom values' do
expect(subject.sanitize_opts(opts)).to include({ release_yum_repo_url: 'https://apt.customserver.net/apt' })
end
it 'overwrites any nil values with pre-defined defaults' do
default_win_url = described_class::FOSS_DEFAULT_DOWNLOAD_URLS[:win_download_url]
expect(subject.sanitize_opts(opts)).to include({ win_download_url: default_win_url })
end
it 'keeps empty strings' do
expect(subject.sanitize_opts(opts)).to include({ dev_builds_url: '' })
end
it 'adds any undefined defaults' do
default_mac_url = described_class::FOSS_DEFAULT_DOWNLOAD_URLS[:mac_download_url]
expect(subject.sanitize_opts(opts)).to include({ mac_download_url: default_mac_url })
end
end
context '#configure_foss_defaults_on' do
it 'uses aio paths for hosts with role aio' do
hosts.each do |host|
host[:pe_ver] = nil
host[:version] = nil
host[:roles] = host[:roles] | ['aio']
end
expect(subject).to receive(:add_foss_defaults_on).exactly(hosts.length).times
expect(subject).to receive(:add_aio_defaults_on).exactly(hosts.length).times
expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
subject.configure_foss_defaults_on(hosts)
end
it 'uses no paths for hosts with no type' do
hosts.each do |host|
host[:type] = nil
end
expect(subject).to receive(:add_aio_defaults_on).never
expect(subject).to receive(:add_foss_defaults_on).never
expect(subject).to receive(:add_puppet_paths_on).never
subject.configure_foss_defaults_on(hosts)
end
it 'uses aio paths for hosts with aio type (backwards compatability)' do
hosts.each do |host|
host[:pe_ver] = nil
host[:version] = nil
host[:type] = 'aio'
end
expect(subject).to receive(:add_aio_defaults_on).exactly(hosts.length).times
expect(subject).to receive(:add_foss_defaults_on).never
expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
subject.configure_foss_defaults_on(hosts)
end
it 'uses aio paths for hosts of version >= 4.0' do
hosts.each do |host|
host[:version] = '4.0'
host[:pe_ver] = nil
host[:roles] = host[:roles] - ['aio']
end
expect(subject).to receive(:add_aio_defaults_on).exactly(hosts.length).times
expect(subject).to receive(:add_foss_defaults_on).exactly(hosts.length).times
expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
subject.configure_foss_defaults_on(hosts)
end
it 'uses foss paths for hosts of version < 4.0' do
hosts.each do |host|
host[:version] = '3.8'
host[:pe_ver] = nil
end
expect(subject).to receive(:add_foss_defaults_on).exactly(hosts.length).times
expect(subject).to receive(:add_aio_defaults_on).never
expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
subject.configure_foss_defaults_on(hosts)
end
it 'uses foss paths for foss-like type foss-package' do
hosts.each do |host|
host[:type] = 'foss-package'
host[:version] = '3.8'
host[:pe_ver] = nil
end
expect(subject).to receive(:add_foss_defaults_on).exactly(hosts.length).times
expect(subject).to receive(:add_aio_defaults_on).never
expect(subject).to receive(:add_puppet_paths_on).exactly(hosts.length).times
subject.configure_foss_defaults_on(hosts)
end
end
context 'lookup_in_env' do
it 'returns a default properly' do
env_var = subject.lookup_in_env('noway', 'nonesuch', 'returnme')
expect(env_var).to eq 'returnme'
env_var = subject.lookup_in_env('noway', nil, 'returnme')
expect(env_var).to eq 'returnme'
end
it 'finds correct env variable' do
allow(ENV).to receive(:[]).with(nil).and_return(nil)
allow(ENV).to receive(:[]).with('REALLYNONE').and_return(nil)
allow(ENV).to receive(:[]).with('NONESUCH').and_return('present')
allow(ENV).to receive(:[]).with('NOWAY_PROJ_NONESUCH').and_return('exists')
env_var = subject.lookup_in_env('nonesuch', 'noway-proj', 'fail')
expect(env_var).to eq 'exists'
env_var = subject.lookup_in_env('nonesuch')
expect(env_var).to eq 'present'
env_var = subject.lookup_in_env('reallynone')
expect(env_var).to eq nil # rubocop:disable Style/NilComparison
env_var = subject.lookup_in_env('reallynone', nil, 'default')
expect(env_var).to eq 'default'
end
end
context 'build_giturl' do
it 'returns urls properly' do
allow(ENV).to receive(:[]).with('SERVER').and_return(nil)
allow(ENV).to receive(:[]).with('FORK').and_return(nil)
allow(ENV).to receive(:[]).with('PUPPET_FORK').and_return(nil)
allow(ENV).to receive(:[]).with('PUPPET_SERVER').and_return(nil)
url = subject.build_giturl('puppet')
expect(url).to eq 'https://github.com/puppetlabs/puppet.git'
url = subject.build_giturl('puppet', 'er0ck')
expect(url).to eq 'https://github.com/er0ck/puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'bitbucket.com')
expect(url).to eq 'https://bitbucket.com/er0ck-puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'https://')
expect(url).to eq 'https://github.com/er0ck/puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'https')
expect(url).to eq 'https://github.com/er0ck/puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'git@')
expect(url).to eq 'git@github.com:er0ck/puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'git')
expect(url).to eq 'git@github.com:er0ck/puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'ssh')
expect(url).to eq 'git@github.com:er0ck/puppet.git'
end
it 'uses ENV to build urls properly' do
allow(ENV).to receive(:[]).with('SERVER').and_return(nil)
allow(ENV).to receive(:[]).with('FORK').and_return(nil)
allow(ENV).to receive(:[]).with('PUPPET_FORK').and_return('er0ck/repo')
allow(ENV).to receive(:[]).with('PUPPET_SERVER').and_return('gitlab.com')
url = subject.build_giturl('puppet')
expect(url).to eq 'https://gitlab.com/er0ck/repo-puppet.git'
url = subject.build_giturl('puppet', 'er0ck')
expect(url).to eq 'https://gitlab.com/er0ck-puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'bitbucket.com')
expect(url).to eq 'https://bitbucket.com/er0ck-puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'https://')
expect(url).to eq 'https://github.com/er0ck/puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'https')
expect(url).to eq 'https://github.com/er0ck/puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'git@')
expect(url).to eq 'git@github.com:er0ck/puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'git')
expect(url).to eq 'git@github.com:er0ck/puppet.git'
url = subject.build_giturl('puppet', 'er0ck', 'github.com', 'ssh')
expect(url).to eq 'git@github.com:er0ck/puppet.git'
end
end
context 'extract_repo_info_from' do
[{ protocol: 'git', path: 'git://github.com/puppetlabs/project.git' },
{ protocol: 'ssh', path: 'git@github.com:puppetlabs/project.git' },
{ protocol: 'https', path: 'https://github.com:puppetlabs/project' },
{ protocol: 'file', path: 'file:///home/example/project' },].each do |type|
it "handles #{type[:protocol]} uris" do
uri = "#{type[:path]}#master"
repo_info = subject.extract_repo_info_from uri
expect(repo_info[:name]).to eq 'project'
expect(repo_info[:path]).to eq type[:path]
expect(repo_info[:rev]).to eq 'master'
end
end
end
context 'order_packages' do
it 'orders facter, hiera before puppet, before anything else' do
named_repos = [
{ name: 'puppet_plugin' }, { name: 'puppet' }, { name: 'facter' },
]
ordered_repos = subject.order_packages named_repos
expect(ordered_repos[0][:name]).to eq 'facter'
expect(ordered_repos[1][:name]).to eq 'puppet'
expect(ordered_repos[2][:name]).to eq 'puppet_plugin'
end
end
context 'find_git_repo_versions' do
it 'returns a hash of :name => version' do
host = double('Host')
repository = { name: 'name' }
path = '/path/to/repo'
cmd = 'cd /path/to/repo/name && git describe || true'
logger = double.as_null_object
allow(subject).to receive(:metadata).and_return(metadata)
expect(subject).to receive(:logger).and_return(logger)
expect(subject).to receive(:on).with(host, cmd).and_yield
expect(subject).to receive(:stdout).and_return('2')
subject.instance_variable_set(:@metadata, {})
version = subject.find_git_repo_versions(host, path, repository)
expect(version).to be == { 'name' => '2' } # rubocop:ignore RSpec/Eq
end
end
context 'install_puppet_from_rpm_on' do
it 'installs puppet release repo when set' do
expect(subject).to receive(:install_puppetlabs_release_repo).with(el6hostaio, 'puppet',
{ puppet_collection: 'puppet' })
subject.install_puppet_from_rpm_on(el6hostaio, { puppet_collection: 'puppet' })
end
it 'installs PC1 release repo when AIO' do
expect(subject).to receive(:install_puppetlabs_release_repo).with(el6hostaio, 'pc1', {})
subject.install_puppet_from_rpm_on(el6hostaio, {})
end
it 'installs non-PC1 package when not-AIO' do
expect(subject).to receive(:install_puppetlabs_release_repo).with(el6hostfoss, nil, {})
subject.install_puppet_from_rpm_on(el6hostfoss, {})
end
end
context 'install_puppet_from_freebsd_ports_on' do
it 'installs puppet on FreeBSD 12' do
expect(freebsdhost12).to receive(:install_package).with('sysutils/puppet7')
subject.install_puppet_from_freebsd_ports_on(freebsdhost12, {})
end
it 'installs puppet on FreeBSD 13' do
expect(freebsdhost13).to receive(:install_package).with('sysutils/puppet7')
subject.install_puppet_from_freebsd_ports_on(freebsdhost13, {})
end
end
context 'install_puppet_from_msi' do
before :each do
[winhost, winhost_non_cygwin].each do |host|
allow(host).to receive(:system_temp_path).and_return(win_temp)
end
end
it 'installs puppet on cygwin windows' do
allow(subject).to receive(:link_exists?).and_return(true)
expect(subject).to receive(:on).with(winhost,
"curl --location --output \"#{win_temp}\\puppet-3.7.1-x64.msi\" --remote-name http://downloads.puppet.com/windows/puppet-3.7.1-x64.msi")
expect(subject).to receive(:on).with(winhost,
" echo 'export PATH=$PATH:\"/cygdrive/c/Program Files (x86)/Puppet Labs/Puppet/bin\":\"/cygdrive/c/Program Files/Puppet Labs/Puppet/bin\"' > /etc/bash.bashrc ")
expect(subject).to receive(:install_msi_on).with(winhost, "#{win_temp}\\puppet-3.7.1-x64.msi", {}, { debug: nil })
subject.install_puppet_from_msi(winhost,
{ version: '3.7.1', win_download_url: 'http://downloads.puppet.com/windows' })
end
it 'installs puppet on cygwin windows via proxy' do
allow(subject).to receive(:link_exists?).and_return(true)
expect(subject).to receive(:on).with(winhost,
"curl -x https://proxy.com --location --output \"#{win_temp}\\puppet-3.7.1-x64.msi\" --remote-name http://downloads.puppet.com/windows/puppet-3.7.1-x64.msi")
expect(subject).to receive(:on).with(winhost,
" echo 'export PATH=$PATH:\"/cygdrive/c/Program Files (x86)/Puppet Labs/Puppet/bin\":\"/cygdrive/c/Program Files/Puppet Labs/Puppet/bin\"' > /etc/bash.bashrc ")
expect(subject).to receive(:install_msi_on).with(winhost, "#{win_temp}\\puppet-3.7.1-x64.msi", {}, { debug: nil })
subject.install_puppet_from_msi(winhost,
{ version: '3.7.1', win_download_url: 'http://downloads.puppet.com/windows',
package_proxy: 'https://proxy.com', })
end
it 'installs puppet on non-cygwin windows' do
allow(subject).to receive(:link_exists?).and_return(true)
expect(winhost_non_cygwin).to receive(:mkdir_p).with('C:\\ProgramData\\PuppetLabs\\puppet\\etc\\modules')
expect(subject).to receive(:on).with(winhost_non_cygwin, instance_of(Beaker::Command)) do |host, beaker_command|
expect(beaker_command.command).to eq('powershell.exe')
expect(beaker_command.args).to eq(['-ExecutionPolicy Bypass', '-InputFormat None', '-NoLogo', '-NoProfile',
'-NonInteractive', "-Command $webclient = New-Object System.Net.WebClient; $webclient.DownloadFile('http://downloads.puppet.com/windows/puppet-3.7.1.msi','#{win_temp}\\puppet-3.7.1.msi')",])
end.once
expect(subject).to receive(:install_msi_on).with(winhost_non_cygwin, "#{win_temp}\\puppet-3.7.1.msi", {},
{ debug: nil })
subject.install_puppet_from_msi(winhost_non_cygwin,
{ version: '3.7.1', win_download_url: 'http://downloads.puppet.com/windows' })
end
it 'installs puppet on non-cygwin windows via proxy' do
allow(subject).to receive(:link_exists?).and_return(true)
expect(winhost_non_cygwin).to receive(:mkdir_p).with('C:\\ProgramData\\PuppetLabs\\puppet\\etc\\modules')
expect(subject).to receive(:on).with(winhost_non_cygwin, instance_of(Beaker::Command)) do |host, beaker_command|
expect(beaker_command.command).to eq('powershell.exe')
expect(beaker_command.args).to eq(['-ExecutionPolicy Bypass', '-InputFormat None', '-NoLogo', '-NoProfile',
'-NonInteractive', "-Command $webclient = New-Object System.Net.WebClient; $webclient.Proxy = New-Object System.Net.WebProxy('https://proxy.com',$true); $webclient.DownloadFile('http://downloads.puppet.com/windows/puppet-3.7.1.msi','#{win_temp}\\puppet-3.7.1.msi')",])
end.once
expect(subject).to receive(:install_msi_on).with(winhost_non_cygwin, "#{win_temp}\\puppet-3.7.1.msi", {},
{ debug: nil })
subject.install_puppet_from_msi(winhost_non_cygwin,
{ version: '3.7.1', win_download_url: 'http://downloads.puppet.com/windows',
package_proxy: 'https://proxy.com', })
end
end
context 'clone_git_repo_on' do
it 'does a ton of stuff it probably shouldnt' do
repo = { name: 'puppet',
path: 'git://my.server.net/puppet.git',
rev: 'master', }
path = '/path/to/repos'
host = { 'platform' => 'debian' }
logger = double.as_null_object
allow(subject).to receive(:metadata).and_return(metadata)
allow(subject).to receive(:configure_foss_defaults_on).and_return(true)
expect(subject).to receive(:logger).exactly(2).times.and_return(logger)
expect(subject).to receive(:on).exactly(3).times
subject.instance_variable_set(:@metadata, {})
subject.clone_git_repo_on(host, path, repo)
end
it 'allows a checkout depth of 1' do
repo = { name: 'puppet',
path: 'git://my.server.net/puppet.git',
rev: 'master',
depth: 1, }
path = '/path/to/repos'
cmd = "test -d #{path}/#{repo[:name]} || git clone --branch #{repo[:rev]} --depth #{repo[:depth]} #{repo[:path]} #{path}/#{repo[:name]}"
host = { 'platform' => 'debian' }
logger = double.as_null_object
allow(subject).to receive(:metadata).and_return(metadata)
allow(subject).to receive(:configure_foss_defaults_on).and_return(true)
expect(subject).to receive(:logger).exactly(2).times.and_return(logger)
expect(subject).to receive(:on).with(host, "test -d #{path} || mkdir -p #{path}",
{ accept_all_exit_codes: true }).exactly(1).times
# this is the the command we want to test
expect(subject).to receive(:on).with(host, cmd, { accept_all_exit_codes: true }).exactly(1).times
expect(subject).to receive(:on).with(host,
"cd #{path}/#{repo[:name]} && git remote rm origin && git remote add origin #{repo[:path]} && git fetch origin +refs/pull/*:refs/remotes/origin/pr/* +refs/heads/*:refs/remotes/origin/* && git clean -fdx && git checkout -f #{repo[:rev]}", { accept_all_exit_codes: true }).exactly(1).times
subject.instance_variable_set(:@metadata, {})
subject.clone_git_repo_on(host, path, repo)
end
it 'allows a checkout depth with a rev from a specific branch' do
repo = { name: 'puppet',
path: 'git://my.server.net/puppet.git',
rev: 'a2340acddadfeafd234230faf',
depth: 50,
depth_branch: 'master', }
path = '/path/to/repos'
cmd = "test -d #{path}/#{repo[:name]} || git clone --branch #{repo[:depth_branch]} --depth #{repo[:depth]} #{repo[:path]} #{path}/#{repo[:name]}"
host = { 'platform' => 'debian' }
allow(subject).to receive(:configure_foss_defaults_on).and_return(true)
logger = double.as_null_object
allow(subject).to receive(:metadata).and_return(metadata)
expect(subject).to receive(:logger).exactly(2).times.and_return(logger)
expect(subject).to receive(:on).with(host, "test -d #{path} || mkdir -p #{path}",
{ accept_all_exit_codes: true }).exactly(1).times
# this is the the command we want to test
expect(subject).to receive(:on).with(host, cmd, { accept_all_exit_codes: true }).exactly(1).times
expect(subject).to receive(:on).with(host,
"cd #{path}/#{repo[:name]} && git remote rm origin && git remote add origin #{repo[:path]} && git fetch origin +refs/pull/*:refs/remotes/origin/pr/* +refs/heads/*:refs/remotes/origin/* && git clean -fdx && git checkout -f #{repo[:rev]}", { accept_all_exit_codes: true }).exactly(1).times
subject.instance_variable_set(:@metadata, {})
subject.clone_git_repo_on(host, path, repo)
end
end
context 'install_from_git' do
it 'does a ton of stuff it probably shouldnt' do
repo = { name: 'puppet',
path: 'git://my.server.net/puppet.git',
rev: 'master', }
path = '/path/to/repos'
host = { 'platform' => 'debian' }
logger = double.as_null_object
allow(subject).to receive(:metadata).and_return(metadata)
allow(subject).to receive(:configure_foss_defaults_on).and_return(true)
expect(subject).to receive(:logger).exactly(3).times.and_return(logger)
expect(subject).to receive(:on).exactly(4).times
subject.instance_variable_set(:@metadata, {})
subject.install_from_git(host, path, repo)
end
it 'should attempt to install ruby code' do
repo = { name: 'puppet',
path: 'git://my.server.net/puppet.git',
rev: 'master',
depth: 1, }
path = '/path/to/repos'
cmd = "test -d #{path}/#{repo[:name]} || git clone --branch #{repo[:rev]} --depth #{repo[:depth]} #{repo[:path]} #{path}/#{repo[:name]}"
host = { 'platform' => 'debian' }
logger = double.as_null_object
allow(subject).to receive(:metadata).and_return(metadata)
allow(subject).to receive(:configure_foss_defaults_on).and_return(true)
expect(subject).to receive(:logger).exactly(3).times.and_return(logger)
expect(subject).to receive(:on).with(host, "test -d #{path} || mkdir -p #{path}",
{ accept_all_exit_codes: true }).exactly(1).times
expect(subject).to receive(:on).with(host, cmd, { accept_all_exit_codes: true }).exactly(1).times
expect(subject).to receive(:on).with(host,
"cd #{path}/#{repo[:name]} && git remote rm origin && git remote add origin #{repo[:path]} && git fetch origin +refs/pull/*:refs/remotes/origin/pr/* +refs/heads/*:refs/remotes/origin/* && git clean -fdx && git checkout -f #{repo[:rev]}", { accept_all_exit_codes: true }).exactly(1).times
expect(subject).to receive(:on).with(host,
"cd #{path}/#{repo[:name]} && if [ -f install.rb ]; then ruby ./install.rb ; else true; fi", { accept_all_exit_codes: true }).exactly(1).times
subject.instance_variable_set(:@metadata, {})
subject.install_from_git_on(host, path, repo)
end
end
describe '#install_puppet' do
let(:hosts) do
make_hosts({ platform: platform })
end
before do
allow(subject).to receive(:options).and_return(opts)
allow(subject).to receive(:hosts).and_return(hosts)
allow(subject).to receive(:on).and_return(Beaker::Result.new({}, ''))
end
context 'on el-6' do
let(:platform) { Beaker::Platform.new('el-6-i386') }
it 'installs' do
expect(hosts[0]).to receive(:install_package_with_rpm).with(/puppet-release-el-6\.noarch\.rpm/,
'--replacepkgs', { package_proxy: false })
expect(hosts[0]).to receive(:install_package).with('puppet')
subject.install_puppet
end
it 'installs in parallel' do
InParallel::InParallelExecutor.logger = logger
FakeFS.deactivate!
hosts.each do |host|
allow(host).to receive(:install_package_with_rpm).with(/puppet-release-el-6\.noarch\.rpm/, '--replacepkgs',
{ package_proxy: false })
allow(host).to receive(:install_package).with('puppet')
end
opts[:run_in_parallel] = true
# This will only get hit if forking processes is supported and at least 2 items are being submitted to run in parallel
expect(InParallel::InParallelExecutor).to receive(:_execute_in_parallel).with(any_args).and_call_original.exactly(3).times
subject.install_puppet(opts)
end
it 'installs specific version of puppet when passed :version' do
expect(hosts[0]).to receive(:install_package).with('puppet-3')
subject.install_puppet(version: '3')
end
it 'can install specific versions of puppets dependencies' do
expect(hosts[0]).to receive(:install_package).with('puppet-3')
expect(hosts[0]).to receive(:install_package).with('hiera-2001')
expect(hosts[0]).to receive(:install_package).with('facter-1999')
subject.install_puppet(version: '3', facter_version: '1999', hiera_version: '2001')
end
end
context 'on el-5' do
let(:platform) { Beaker::Platform.new('el-5-i386') }
it 'installs' do
expect(hosts[0]).to receive(:install_package_with_rpm).with(/puppet-release-el-5.noarch.rpm/, '--replacepkgs',
{ package_proxy: false })
expect(hosts[0]).to receive(:install_package).with('puppet')
subject.install_puppet
end
end
context 'on fedora' do
let(:platform) { Beaker::Platform.new('fedora-18-x86_84') }
it 'installs' do
expect(hosts[0]).to receive(:install_package_with_rpm).with(/puppet-release-fedora-18.noarch.rpm/,
'--replacepkgs', { package_proxy: false })
expect(hosts[0]).to receive(:install_package).with('puppet')
subject.install_puppet
end
end
context 'on archlinux' do
let(:platform) { Beaker::Platform.new('archlinux-2015.09.01-x86_84') }
it 'installs' do
expect(hosts[0]).to receive(:install_package).with('puppet')
subject.install_puppet
end
end
context 'on freebsd' do
let(:platform) { Beaker::Platform.new('freebsd-13-amd64') }
it 'installs' do
expect(hosts[0]).to receive(:install_package).with('sysutils/puppet7')
subject.install_puppet
end
end
context 'on debian' do
PlatformHelpers::DEBIANPLATFORMS.each do |platform|
let(:platform) { Beaker::Platform.new("#{platform}-ver-arch") }
it "installs latest on #{platform} if given no version info" do
hosts.each do |host|
expect(subject).to receive(:install_puppetlabs_release_repo).with(host)
end
expect(hosts[0]).to receive(:install_package).with('puppet')
subject.install_puppet
end
end
it 'installs specific version of puppet when passed :version' do
expect(hosts[0]).to receive(:install_package).with('puppet=3-1puppetlabs1')
expect(hosts[0]).to receive(:install_package).with('puppet-common=3-1puppetlabs1')
subject.install_puppet(version: '3')
end
it 'can install specific versions of puppets dependencies' do
expect(hosts[0]).to receive(:install_package).with('facter=1999-1puppetlabs1')
expect(hosts[0]).to receive(:install_package).with('hiera=2001-1puppetlabs1')
expect(hosts[0]).to receive(:install_package).with('puppet-common=3-1puppetlabs1')
expect(hosts[0]).to receive(:install_package).with('puppet=3-1puppetlabs1')
subject.install_puppet(version: '3', facter_version: '1999', hiera_version: '2001')
end
end
context 'on windows' do
let(:platform) { Beaker::Platform.new('windows-2008r2-i386') }
before :each do
allow(winhost).to receive(:tmpdir).and_return(win_temp)
allow(winhost).to receive(:is_cygwin?).and_return(true)
allow(subject).to receive(:link_exists?).and_return(true)
allow(subject).to receive(:install_msi_on).with(any_args)
end
it 'installs specific version of puppet when passed :version' do
hosts.each do |host|
if host == winhost
expect(subject).to receive(:on).with(winhost, "curl -o \"#{win_temp}\\puppet-3.msi\" -O http://downloads.puppet.com/windows/puppet-3.msi")
expect(subject).to receive(:on).with(winhost,
" echo 'export PATH=$PATH:\"/cygdrive/c/Program Files (x86)/Puppet Labs/Puppet/bin\":\"/cygdrive/c/Program Files/Puppet Labs/Puppet/bin\"' > /etc/bash.bashrc ")
expect(subject).to receive(:install_msi_on).with(winhost, "#{win_temp}\\puppet-3.msi", {},
{ debug: nil }).exactly(1).times
else
allow(subject).to receive(:on).with(host, anything)
end
end
subject.install_puppet(version: '3')
end
it 'installs from custom url when passed :win_download_url' do
hosts.each do |host|
if host == winhost
expect(subject).to receive(:on).with(winhost, "curl -o \"#{win_temp}\\puppet-3.msi\" -O http://nightlies.puppet.com/puppet-latest/repos/windows/puppet-3.msi")
expect(subject).to receive(:install_msi_on).with(winhost, "#{win_temp}\\puppet-3.msi", {}, { debug: nil })
else
allow(subject).to receive(:on).with(host, anything)
end
end
subject.install_puppet(version: '3',
win_download_url: 'http://nightlies.puppet.com/puppet-latest/repos/windows')
end
end
describe 'on unsupported platforms' do
let(:platform) { Beaker::Platform.new('solaris-11-x86_64') }
let(:host) { make_host('henry', platform: 'solaris-11-x86_64') }
let(:hosts) { [host] }
it 'by default raises an error' do
expect(subject).to_not receive(:on)
expect { subject.install_puppet }.to raise_error(/unsupported platform/)
end
it 'falls back to installing from gem when given :default_action => "gem_install"' do
result = double
gem_env_string = '{"RubyGems Environment": [ {"GEM PATHS": [], "EXECUTABLE DIRECTORY": "/does/not/exist" } ] }'
allow(result).to receive(:stdout).and_return gem_env_string
allow(subject).to receive(:on).with(host, /gem environment/).and_return result
expect(subject).to receive(:on).with(host, /gem install/)
subject.install_puppet default_action: 'gem_install'
end
end
end
describe 'configure_puppet_on' do
context 'on debian' do
PlatformHelpers::DEBIANPLATFORMS.each do |platform|
let(:platform) { Beaker::Platform.new("#{platform}-ver-arch") }
let(:host) { make_host('testbox.test.local', platform: "#{platform}") }
it "it sets the puppet.conf file to the provided config on #{platform}" do
config = { 'main' => { 'server' => 'testbox.test.local' } }
expected_config_string = "[main]\nserver=testbox.test.local\n\n"
expect(subject).to receive(:create_remote_file).with(
host, anything, expected_config_string
)
subject.configure_puppet_on(host, config)
end
end
end
context 'on windows' do
let(:platform) { 'windows-2008R2-amd64' }
let(:host) { make_host('testbox.test.local', platform: 'windows-2008R2-amd64') }
it 'it sets the puppet.conf file to the provided config' do
config = { 'main' => { 'server' => 'testbox.test.local' } }
expected_config_string = "[main]\nserver=testbox.test.local\n\n"
expect(subject).to receive(:create_remote_file).with(
host, anything, expected_config_string
)
subject.configure_puppet_on(host, config)
end
end
end
describe 'configure_puppet' do
let(:hosts) do
make_hosts({ platform: platform })
end
before do
allow(subject).to receive(:hosts).and_return(hosts)
allow(subject).to receive(:on).and_return(Beaker::Result.new({}, ''))
end
context 'on debian' do
PlatformHelpers::DEBIANPLATFORMS.each do |platform|
let(:platform) { Beaker::Platform.new("#{platform}-ver-arch") }
it "calls configure_puppet_on correctly on #{platform}" do
config = { 'main' => { 'server' => 'testbox.test.local' } }
expect(subject).to receive(:configure_puppet_on).with(
anything, config
).exactly(hosts.length).times
subject.configure_puppet(config)
end
end
end
context 'on windows' do
let(:platform) { 'windows-2008R2-amd64' }
it 'calls configure_puppet_on correctly' do
config = { 'main' => { 'server' => 'testbox.test.local' } }
expect(subject).to receive(:configure_puppet_on).with(
anything, config
).exactly(hosts.length).times
subject.configure_puppet(config)
end
end
end
describe '#install_puppetlabs_release_repo' do
let(:platform) { Beaker::Platform.new('solaris-7-i386') }
let(:host) do
FakeHost.create('fakevm', platform.to_s)
end
before do
allow(subject).to receive(:options) { opts }
allow(subject).to receive(:configure_foss_defaults_on).and_return(true)
end
describe 'When host is unsupported platform' do
let(:platform) { Beaker::Platform.new('solaris-7-i386') }
it 'raises an exception.' do
expect do
subject.install_puppetlabs_release_repo host
end.to raise_error(RuntimeError, /No repository installation step for/)
end
end
describe 'When host is a debian-like platform' do
let(:platform) { Beaker::Platform.new('debian-7-i386') }
it 'downloads a deb file, installs, and updates the apt cache.' do
expect(subject).to receive(:on).with(host, /wget .*/).ordered
expect(subject).to receive(:on).with(host, /dpkg .*/).ordered
expect(subject).to receive(:on).with(host, 'apt-get update').ordered
subject.install_puppetlabs_release_repo host
end
end
end
describe '#install_puppetlabs_release_repo_on' do
let(:host) do
FakeHost.create('fakevm', platform.to_s)
end
before :each do
allow(subject).to receive(:options) { opts }
end
context 'on el 7' do
let(:platform) { Beaker::Platform.new('el-7-x86_64') }
it 'returns the correct url when repo is set to puppet8' do
expect(host).to receive(:install_package_with_rpm).with(/puppet8-release-el-7\.noarch\.rpm$/,
'--replacepkgs', { package_proxy: false })
subject.install_puppetlabs_release_repo_on(host, 'puppet8')
end
it 'returns the correct url when opts[:puppet_collection] is set to puppet14' do
expect(host).to receive(:install_package_with_rpm).with(/puppet14-release-el-7\.noarch\.rpm$/,
'--replacepkgs', { package_proxy: false })
subject.install_puppetlabs_release_repo_on(host, nil, { puppet_collection: 'puppet14' })
end
it 'returns the correct url when both repo and opts[:puppet_collection] are nil' do
expect(host).to receive(:install_package_with_rpm).with(/puppet-release-el-7\.noarch\.rpm$/,
'--replacepkgs', { package_proxy: false })
subject.install_puppetlabs_release_repo_on(host)
end
end
context 'on debian 8' do
let(:platform) { Beaker::Platform.new('debian-8-i386') }
it 'returns the correct url when repo is set to puppet4' do
expect(subject).to receive(:on).with(host, /puppet4-release-jessie\.deb$/).once
expect(subject).to receive(:on).with(host, 'dpkg -i --force-all /tmp/puppet.deb').once
expect(subject).to receive(:on).with(host, 'apt-get update').once
subject.install_puppetlabs_release_repo_on(host, 'puppet4')
end
it 'returns the correct url when opts[:puppet_collection] is set to puppet7' do
expect(subject).to receive(:on).with(host, /puppet7-release-jessie\.deb$/).once
expect(subject).to receive(:on).with(host, 'dpkg -i --force-all /tmp/puppet.deb').once
expect(subject).to receive(:on).with(host, 'apt-get update').once
subject.install_puppetlabs_release_repo_on(host, nil, { puppet_collection: 'puppet7' })
end
it 'returns the correct url when both repo and opts[:puppet_collection] are nil' do
expect(subject).to receive(:on).with(host, /puppet-release-jessie\.deb$/).once
expect(subject).to receive(:on).with(host, 'dpkg -i --force-all /tmp/puppet.deb').once
expect(subject).to receive(:on).with(host, 'apt-get update').once
subject.install_puppetlabs_release_repo_on(host)
end
end
context 'on cisco platforms' do
context 'version 5' do
let(:platform) { Beaker::Platform.new('cisco_nexus-7-x86_64') }
it 'calls host.install_package' do
expect(host).to receive(:install_package).with(/\.rpm$/)
subject.install_puppetlabs_release_repo_on(host)
end
end
context 'version 7' do
let(:platform) { Beaker::Platform.new('cisco_ios_xr-6-x86_64') }
it 'uses yum localinstall to install the package' do
expect(subject).to receive(:on).with(host, /^yum.*localinstall.*\.rpm$/)
subject.install_puppetlabs_release_repo_on(host)
end
end
end
end
describe '#install_puppetlabs_dev_repo' do
let(:package_name) { 'puppet' }
let(:package_version) { '7.5.6' }
let(:host) do
h = FakeHost.create('fakvm', platform.to_s, opts)
allow(h).to receive(:link_exists?).and_return(true)
h
end
let(:logger_double) do
logger_double = Object.new
allow(logger_double).to receive(:debug)
allow(logger_double).to receive(:trace)
allow(subject).to receive(:configure_foss_defaults_on).and_return(true)
subject.instance_variable_set(:@logger, logger_double)
logger_double
end
RSpec.shared_examples 'install-dev-repo' do
it "scp's files to SUT then modifies them with find-and-sed 2-hit combo" do
allow(rez).to receive(:exit_code) { 0 }
allow(subject).to receive(:link_exists?).and_return(true)
expect(subject).to receive(:scp_to).with(host, repo_config, /.*/).ordered
subject.install_puppetlabs_dev_repo host, package_name, package_version
end
end
describe 'When host is unsupported platform' do
let(:platform) { Beaker::Platform.new('solaris-7-i386') }
it 'raises an exception.' do
# expect(subject).to receive(:on).with( host, /^mkdir -p .*$/ ).ordered
allow(subject).to receive(:options) { opts }
expect do
subject.install_puppetlabs_dev_repo host, package_name, package_version
end.to raise_error(RuntimeError, /No repository installation step for/)
end
end
describe 'When on supported platforms' do
# These are not factored into the `before` block above because they
# are expectations in the share examples, but aren't interesting
# beyond those basic tests
def stub_uninteresting_portions_of_install_puppetlabs_dev_repo!
allow(subject).to receive(:scp_to).with(host, repo_config, /.*/).ordered
end
let(:repo_config) { 'repoconfig' }
let(:repo_dir) { 'repodir' }
let(:rez) { double }
before do
allow(subject).to receive(:fetch_http_file) { repo_config }
allow(subject).to receive(:fetch_http_dir) { repo_dir }
allow(subject).to receive(:on).with(host, 'apt-get update') {}
allow(subject).to receive(:options) { opts }
allow(subject).to receive(:on).with(host, /^.* -d .*/, { acceptable_exit_codes: [0, 1] }).and_return(rez)
end
describe 'that are debian-like' do
PlatformHelpers::DEBIANPLATFORMS.each do |platform|
let(:platform) { Beaker::Platform.new("#{platform}-ver-arch") }
before { allow(subject).to receive(:link_exists?).and_return(true) }
include_examples 'install-dev-repo'
end
end
describe 'that are redhat-like' do
let(:platform) { Beaker::Platform.new('el-7-i386') }
include_examples 'install-dev-repo'
end
end
end
describe '#install_packages_from_local_dev_repo' do
let(:package_name) { 'puppet-agent' }
let(:platform) { @platform || 'other' }
let(:host) do
FakeHost.create('fakvm', platform, opts)
end
before :each do
allow(subject).to receive(:configure_foss_defaults_on).and_return(true)
end
it 'sets the find command correctly for el-based systems' do
@platform = 'el-1-3'
expect(subject).to receive(:on).with(host, /\*\.rpm.+rpm\s-ivh/)
subject.install_packages_from_local_dev_repo(host, package_name)
end
it 'sets the find command correctly for debian-based systems' do
@platform = 'debian-1-3'
expect(subject).to receive(:on).with(host, /\*\.deb.+dpkg\s-i/)
subject.install_packages_from_local_dev_repo(host, package_name)
end
it 'fails correctly for systems not accounted for' do
@platform = 'eos-1-3'
expect { subject.install_packages_from_local_dev_repo(host, package_name) }.to raise_error RuntimeError
end
end
describe '#msi_link_path' do
let(:opts) { { puppet_agent_version: 'VERSION', win_download_url: 'http://downloads.puppet.com/windows' } }
let(:platform) { 'windows' }
let(:host) { { :platform => platform, 'dist' => 'puppet-agent-VERSION-x64' } }
it 'returns the right link when puppet collection is set' do
allow(subject).to receive(:link_exists?).with(anything).and_return(true)
expect(subject.msi_link_path(host,
opts.merge({ puppet_collection: 'puppet' }))).to eq "#{opts[:win_download_url]}/puppet/puppet-agent-VERSION-x64.msi"
end
it 'returns the right link when puppet collection is not set' do
expect(subject).to receive(:link_exists?).with(anything).and_return(true)
expect(subject.msi_link_path(host, opts)).to eq "#{opts[:win_download_url]}/puppet-agent-VERSION-x64.msi"
end
it 'returns error when link incorrect' do
allow(subject).to receive(:link_exists?).with(anything).and_return(false)
expect do
subject.msi_link_path(host, opts)
end.to raise_error(RuntimeError,
%r{Puppet MSI at http://downloads.puppet.com/windows/puppet-agent-VERSION-x64.msi does not exist!})
end
end
describe '#install_puppet_agent_from_msi_on' do
let(:opts) { { puppet_agent_version: 'VERSION', win_download_url: 'http://downloads.puppet.com/windows' } }
let(:platform) { 'windows' }
let(:host) { { platform: platform } }
it 'uses x86 msi when host is_x86_64 and install_32 is set on the host' do
host['install_32'] = true
expect(host).to receive(:is_x86_64?).and_return(true)
expect(subject).to receive(:install_a_puppet_msi_on).with(host, opts)
subject.install_puppet_agent_from_msi_on(host, opts)
expect(host['dist']).to eq 'puppet-agent-VERSION-x86'
end
it 'uses x86 msi when host is_x86_64 and install_32 is set on the options' do
opts['install_32'] = true
expect(host).to receive(:is_x86_64?).and_return(true)
expect(subject).to receive(:install_a_puppet_msi_on).with(host, opts)
subject.install_puppet_agent_from_msi_on(host, opts)
expect(host['dist']).to eq 'puppet-agent-VERSION-x86'
end
it 'uses x86 msi when host is_x86_64 and ruby_arch is x86 on the host' do
host['ruby_arch'] = 'x86'
expect(host).to receive(:is_x86_64?).and_return(true)
expect(subject).to receive(:install_a_puppet_msi_on).with(host, opts)
subject.install_puppet_agent_from_msi_on(host, opts)
expect(host['dist']).to eq 'puppet-agent-VERSION-x86'
end
it 'uses x86 msi when host !is_x86_64' do
expect(host).to receive(:is_x86_64?).and_return(false)
expect(subject).to receive(:install_a_puppet_msi_on).with(host, opts)
subject.install_puppet_agent_from_msi_on(host, opts)
expect(host['dist']).to eq 'puppet-agent-VERSION-x86'
end
it 'uses x64 msi when host is_x86_64, no install_32 and ruby_arch != x86' do
expect(host).to receive(:is_x86_64?).and_return(true)
expect(subject).to receive(:install_a_puppet_msi_on).with(host, opts)
subject.install_puppet_agent_from_msi_on(host, opts)
expect(host['dist']).to eq 'puppet-agent-VERSION-x64'
end
end
describe '#install_cert_on_windows' do
before do
allow(subject).to receive(:on).and_return(Beaker::Result.new({}, ''))
end
context 'on windows' do
let(:platform) { 'windows-2008R2-amd64' }
let(:host) { make_host('testbox.test.local', platform: 'windows-2008R2-amd64') }
it 'should install all 3 certs' do
cert = 'geotrust_global_ca'
content = <<-EOM
-----BEGIN CERTIFICATE-----
MIIDVDCCAjygAwIBAgIDAjRWMA0GCSqGSIb3DQEBBQUAMEIxCzAJBgNVBAYTAlVT
MRYwFAYDVQQKEw1HZW9UcnVzdCBJbmMuMRswGQYDVQQDExJHZW9UcnVzdCBHbG9i
YWwgQ0EwHhcNMDIwNTIxMDQwMDAwWhcNMjIwNTIxMDQwMDAwWjBCMQswCQYDVQQG
EwJVUzEWMBQGA1UEChMNR2VvVHJ1c3QgSW5jLjEbMBkGA1UEAxMSR2VvVHJ1c3Qg
R2xvYmFsIENBMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA2swYYzD9
9BcjGlZ+W988bDjkcbd4kdS8odhM+KhDtgPpTSEHCIjaWC9mOSm9BXiLnTjoBbdq
fnGk5sRgprDvgOSJKA+eJdbtg/OtppHHmMlCGDUUna2YRpIuT8rxh0PBFpVXLVDv
iS2Aelet8u5fa9IAjbkU+BQVNdnARqN7csiRv8lVK83Qlz6cJmTM386DGXHKTubU
1XupGc1V3sjs0l44U+VcT4wt/lAjNvxm5suOpDkZALeVAjmRCw7+OC7RHQWa9k0+
bw8HHa8sHo9gOeL6NlMTOdReJivbPagUvTLrGAMoUgRx5aszPeE4uwc2hGKceeoW
MPRfwCvocWvk+QIDAQABo1MwUTAPBgNVHRMBAf8EBTADAQH/MB0GA1UdDgQWBBTA
ephojYn7qwVkDBF9qn1luMrMTjAfBgNVHSMEGDAWgBTAephojYn7qwVkDBF9qn1l
uMrMTjANBgkqhkiG9w0BAQUFAAOCAQEANeMpauUvXVSOKVCUn5kaFOSPeCpilKIn
Z57QzxpeR+nBsqTP3UEaBU6bS+5Kb1VSsyShNwrrZHYqLizz/Tt1kL/6cdjHPTfS
tQWVYrmm3ok9Nns4d0iXrKYgjy6myQzCsplFAMfOEVEiIuCl6rYVSAlk6l5PdPcF
PseKUgzbFbS9bZvlxrFUaKnjaZC2mqUPuLk/IH2uSrW4nOQdtqvmlKXBx4Ot2/Un
hw4EbNX/3aBd7YdStysVAq45pmp06drE57xNNB6pXE0zX5IJL4hmXXeXxx12E6nV
5fEWCRE11azbJHFwLJhWC9kXtNHjUStedejV0NxPNO3CBWaAocvmMw==
-----END CERTIFICATE-----
EOM
expect(subject).to receive(:create_remote_file) do |host, file_path, file_content|
expect(file_path).to eq("C:\\Windows\\Temp\\#{cert}.pem")
end
expect(subject).to receive(:on) do |host, command|
expect(command).to eq("certutil -v -addstore Root C:\\Windows\\Temp\\#{cert}.pem")
end
subject.install_cert_on_windows(host, cert, content)
end
end
end
describe '#install_puppetserver_on' do
let(:host) { make_host('master', platform: 'el-7-x86_64') }
context 'with default arguments' do
it "installs the latest puppetserver from the default 'puppet' release stream" do
expect(subject).to receive(:install_puppetlabs_release_repo_on).with(host, 'puppet',
include(release_yum_repo_url: 'https://yum.puppet.com'))
expect(subject).to receive(:install_package).with(host, 'puppetserver', nil)
subject.install_puppetserver_on(host)
end
end
context 'with a version option' do
version = '6.6.6'
context 'on deb-based platform' do
let(:host) { make_host('master', platform: Beaker::Platform.new('ubuntu-16.04-amd64')) }
it 'munges the version on ubuntu 16.04' do
expect(subject).to receive(:install_puppetlabs_release_repo_on).with(host, 'puppet', anything)
expect(subject).to receive(:install_package).with(host, 'puppetserver', "#{version}-1xenial")
allow(subject).to receive(:dev_builds_accessible_on?).with(host, anything).and_return false
subject.install_puppetserver_on(host, version: version)
end
end
it 'installs puppetserver at the specific version from internal buildservers' do
expect(subject).to receive(:install_from_build_data_url).with('puppetserver',
/^#{described_class::FOSS_DEFAULT_DOWNLOAD_URLS[:dev_builds_url]}.*#{version}/, host)
allow(subject).to receive(:dev_builds_accessible_on?).with(host, anything).and_return true
subject.install_puppetserver_on(host, version: version)
end
it 'installs puppetserver from the custom dev builds URL' do
dev_builds_url = 'http://builds.corp.tld'
expect(subject).to receive(:install_from_build_data_url).with('puppetserver', /^#{dev_builds_url}.*#{version}/,
host)
allow(subject).to receive(:dev_builds_accessible_on?).with(host, anything).and_return true
subject.install_puppetserver_on(host, version: version, dev_builds_url: dev_builds_url)
end
it 'installs puppetserver from the main repo if a broken url is passed in' do
dev_builds_url = 'http://builds.corp.tld'
allow(subject).to receive(:dev_builds_accessible_on?).with(host, dev_builds_url).and_return false
expect(subject).to receive(:install_puppetlabs_release_repo_on).with(host, 'puppet', include(version: '6.6.6'))
expect(subject).to receive(:install_package).with(host, 'puppetserver', '6.6.6')
subject.install_puppetserver_on(host, version: version, dev_builds_url: dev_builds_url)
end
it 'installs from a custom release stream' do
release_stream = 'puppet6'
allow(subject).to receive(:dev_builds_accessible_on?).with(host, anything).and_return false
expect(subject).to receive(:install_puppetlabs_release_repo_on).with(host,
release_stream,
include(version: '6.6.6'))
expect(subject).to receive(:install_package).with(host, 'puppetserver', '6.6.6')
subject.install_puppetserver_on(host, release_stream: release_stream, version: version)
end
it 'installs puppetserver from the default release stream' do
allow(subject).to receive(:dev_builds_accessible_on?).with(host, anything).and_return false
expect(subject).to receive(:install_puppetlabs_release_repo_on).with(host, 'puppet', include(version: '6.6.6'))
expect(subject).to receive(:install_package).with(host, 'puppetserver', '6.6.6')
subject.install_puppetserver_on(host, version: version)
end
end
context 'with the nightlies option' do
it 'installs puppetserver from the default puppet nightly repos' do
expect(subject).to receive(:install_puppetlabs_release_repo_on)
.with(host, 'puppet-nightly', include(
nightly_yum_repo_url: described_class::FOSS_DEFAULT_DOWNLOAD_URLS[:nightly_yum_repo_url],
nightly_apt_repo_url: described_class::FOSS_DEFAULT_DOWNLOAD_URLS[:nightly_apt_repo_url],
))
subject.install_puppetserver_on(host, nightlies: true)
end
context 'with custom nightlies urls' do
custom_nightlies_url = 'http://nightlies.corp.tld'
it 'uses a custom general nightlies url' do
expect(subject).to receive(:install_puppetlabs_release_repo_on)
.with(host, 'puppet-nightly', include(
nightly_yum_repo_url: custom_nightlies_url,
nightly_apt_repo_url: custom_nightlies_url,
))
subject.install_puppetserver_on(host, nightlies: true, nightly_builds_url: custom_nightlies_url)
end
it 'uses a custom yum repo url' do
expect(subject).to receive(:install_puppetlabs_release_repo_on)
.with(host, 'puppet-nightly', include(
nightly_yum_repo_url: custom_nightlies_url,
))
subject.install_puppetserver_on(host, nightlies: true, nightly_yum_repo_url: custom_nightlies_url)
end
it 'uses a custom apt repo url' do
expect(subject).to receive(:install_puppetlabs_release_repo_on)
.with(host, 'puppet-nightly', include(
nightly_apt_repo_url: custom_nightlies_url,
))
subject.install_puppetserver_on(host, nightlies: true, nightly_apt_repo_url: custom_nightlies_url)
end
end
end
end
describe '#remove_puppet_on' do
supported_platforms = ['aix-53-power',
'aix-61-power',
'aix-71-power',
'solaris-10-x86_64',
'solaris-10-x86_64',
'solaris-11-x86_64',
'el-6-x86_64',
'redhat-7-x86_64',
'centos-7-x86_64',
'oracle-7-x86_64',
'scientific-7-x86_64',
'sles-10-x86_64',
'sles-11-x86_64',
'sles-12-s390x',
'ubuntu-16.04-power8',]
supported_platforms.each do |platform|
let(:host) { make_host(platform, platform: platform) }
pkg_list = 'foo bar'
it "uninstalls packages on #{platform}" do
result = Beaker::Result.new(host, '')
result.stdout = pkg_list
expected_list = pkg_list
cmd_args = ''
expect(subject).to receive(:on).exactly(2).times.and_return(result, result)
expect(host).to receive(:uninstall_package).with(expected_list, cmd_args)
subject.remove_puppet_on(host)
end
end
let(:debian6) { make_host('debian-6-amd64', platform: 'debian-6-amd64') }
it 'raises error on unsupported platforms' do
expect { subject.remove_puppet_on(debian6) }.to raise_error(RuntimeError, /unsupported platform/)
end
end
end