puppet 8.3.1-x64-mingw32 → 8.5.0-x64-mingw32

data/spec/unit/provider/package/portage_spec.rb

@@ -1,226 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:portage) do
-  before do
-    packagename = "sl"
-    @resource = double('resource', :should => true)
-    allow(@resource).to receive(:[]).with(:name).and_return(packagename)
-    allow(@resource).to receive(:[]).with(:install_options).and_return(['--foo', '--bar'])
-    allow(@resource).to receive(:[]).with(:uninstall_options).and_return(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
-
-    unslotted_packagename = "dev-lang/ruby"
-    @unslotted_resource = double('resource', :should => true)
-    allow(@unslotted_resource).to receive(:should).with(:ensure).and_return(:latest)
-    allow(@unslotted_resource).to receive(:[]).with(:name).and_return(unslotted_packagename)
-    allow(@unslotted_resource).to receive(:[]).with(:install_options).and_return([])
-
-    slotted_packagename = "dev-lang/ruby:2.1"
-    @slotted_resource = double('resource', :should => true)
-    allow(@slotted_resource).to receive(:[]).with(:name).and_return(slotted_packagename)
-    allow(@slotted_resource).to receive(:[]).with(:install_options).and_return(['--foo', { '--bar' => 'baz', '--baz' => 'foo' }])
-
-    versioned_packagename = "=dev-lang/ruby-1.9.3"
-    @versioned_resource = double('resource', :should => true)
-    allow(@versioned_resource).to receive(:[]).with(:name).and_return(versioned_packagename)
-    allow(@versioned_resource).to receive(:[]).with(:install_options).and_return([])
-    allow(@versioned_resource).to receive(:[]).with(:uninstall_options).and_return([])
-
-    versioned_slotted_packagename = "=dev-lang/ruby-1.9.3:1.9"
-    @versioned_slotted_resource = double('resource', :should => true)
-    allow(@versioned_slotted_resource).to receive(:[]).with(:name).and_return(versioned_slotted_packagename)
-    allow(@versioned_slotted_resource).to receive(:[]).with(:install_options).and_return([])
-    allow(@versioned_slotted_resource).to receive(:[]).with(:uninstall_options).and_return([])
-
-    set_packagename = "@system"
-    @set_resource = double('resource', :should => true)
-    allow(@set_resource).to receive(:[]).with(:name).and_return(set_packagename)
-    allow(@set_resource).to receive(:[]).with(:install_options).and_return([])
-
-    package_sets = "system\nworld\n"
-    @provider = described_class.new(@resource)
-    allow(@provider).to receive(:qatom).and_return({:category=>nil, :pn=>"sl", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
-    allow(@provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-    @unslotted_provider = described_class.new(@unslotted_resource)
-    allow(@unslotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
-    allow(@unslotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-    @slotted_provider = described_class.new(@slotted_resource)
-    allow(@slotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>nil, :pr=>nil, :slot=>"2.1", :pfx=>nil, :sfx=>nil})
-    allow(@slotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-    @versioned_provider = described_class.new(@versioned_resource)
-    allow(@versioned_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>nil, :pfx=>"=", :sfx=>nil})
-    allow(@versioned_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-    @versioned_slotted_provider = described_class.new(@versioned_slotted_resource)
-    allow(@versioned_slotted_provider).to receive(:qatom).and_return({:category=>"dev-lang", :pn=>"ruby", :pv=>"1.9.3", :pr=>nil, :slot=>"1.9", :pfx=>"=", :sfx=>nil})
-    allow(@versioned_slotted_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-    @set_provider = described_class.new(@set_resource)
-    allow(@set_provider).to receive(:qatom).and_return({:category=>nil, :pn=>"@system", :pv=>nil, :pr=>nil, :slot=>nil, :pfx=>nil, :sfx=>nil})
-    allow(@set_provider.class).to receive(:emerge).with('--list-sets').and_return(package_sets)
-
-    portage   = double(:executable => "foo",:execute => true)
-    allow(Puppet::Provider::CommandDefiner).to receive(:define).and_return(portage)
-
-    @nomatch_result = ""
-    @match_result    = "app-misc sl [] [5.02] [] [] [5.02] [5.02:0] http://www.tkl.iis.u-tokyo.ac.jp/~toyoda/index_e.html https://github.com/mtoyoda/sl/ sophisticated graphical program which corrects your miss typing\n"
-    @slot_match_result = "dev-lang ruby [2.1.8] [2.1.9] [2.1.8:2.1] [2.1.8] [2.1.9,,,,,,,] [2.1.9:2.1] http://www.ruby-lang.org/ An object-oriented scripting language\n"
-  end
-
-  it "is versionable" do
-    expect(described_class).to be_versionable
-  end
-
-  it "is reinstallable" do
-    expect(described_class).to be_reinstallable
-  end
-
-  it "should be the default provider on 'os.family' => Gentoo" do
-    expect(Facter).to receive(:value).with('os.family').and_return("Gentoo")
-    expect(described_class.default?).to be_truthy
-  end
-
-  it 'should support string install options' do
-    expect(@provider).to receive(:emerge).with('--foo', '--bar', @resource[:name])
-
-    @provider.install
-  end
-
-  it 'should support updating' do
-    expect(@unslotted_provider).to receive(:emerge).with('--update', @unslotted_resource[:name])
-
-    @unslotted_provider.install
-  end
-
-  it 'should support hash install options' do
-    expect(@slotted_provider).to receive(:emerge).with('--foo', '--bar=baz', '--baz=foo', @slotted_resource[:name])
-
-    @slotted_provider.install
-  end
-
-  it 'should support hash uninstall options' do
-    expect(@provider).to receive(:emerge).with('--rage-clean', '--foo', '--bar=baz', '--baz=foo', @resource[:name])
-
-    @provider.uninstall
-  end
-
-  it 'should support install of specific version' do
-    expect(@versioned_provider).to receive(:emerge).with(@versioned_resource[:name])
-
-    @versioned_provider.install
-  end
-
-  it 'should support install of specific version and slot' do
-    expect(@versioned_slotted_provider).to receive(:emerge).with(@versioned_slotted_resource[:name])
-
-    @versioned_slotted_provider.install
-  end
-
-  it 'should support uninstall of specific version' do
-    expect(@versioned_provider).to receive(:emerge).with('--rage-clean', @versioned_resource[:name])
-
-    @versioned_provider.uninstall
-  end
-
-  it 'should support uninstall of specific version and slot' do
-    expect(@versioned_slotted_provider).to receive(:emerge).with('--rage-clean', @versioned_slotted_resource[:name])
-
-    @versioned_slotted_provider.uninstall
-  end
-
-  it "uses :emerge to install packages" do
-    expect(@provider).to receive(:emerge)
-
-    @provider.install
-  end
-
-  it "uses query to find the latest package" do
-    expect(@provider).to receive(:query).and_return({:versions_available => "myversion"})
-
-    @provider.latest
-  end
-
-  it "uses eix to search the lastest version of a package" do
-    allow(@provider).to receive(:update_eix)
-    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
-
-    @provider.query
-  end
-
-  it "allows to emerge package sets" do
-    expect(@set_provider).to receive(:emerge).with(@set_resource[:name])
-
-    @set_provider.install
-  end
-
-  it "allows to emerge and update package sets" do
-    allow(@set_resource).to receive(:should).with(:ensure).and_return(:latest)
-    expect(@set_provider).to receive(:emerge).with('--update', @set_resource[:name])
-
-    @set_provider.install
-  end
-
-  it "eix arguments must not include --stable" do
-    expect(@provider.class.eix_search_arguments).not_to include("--stable")
-  end
-
-  it "eix arguments must not include --exact" do
-    expect(@provider.class.eix_search_arguments).not_to include("--exact")
-  end
-
-  it "query uses default arguments" do
-    allow(@provider).to receive(:update_eix)
-    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
-    expect(@provider.class).to receive(:eix_search_arguments).and_return([])
-
-    @provider.query
-  end
-
-  it "can handle search output with empty square brackets" do
-    allow(@provider).to receive(:update_eix)
-    expect(@provider).to receive(:eix).and_return(StringIO.new(@match_result))
-
-    expect(@provider.query[:name]).to eq("sl")
-  end
-
-  it "can provide the package name without slot" do
-    expect(@unslotted_provider.qatom[:slot]).to be_nil
-  end
-
-  it "can extract the slot from the package name" do
-    expect(@slotted_provider.qatom[:slot]).to eq('2.1')
-  end
-
-  it "returns nil for as the slot when no slot is specified" do
-    expect(@provider.qatom[:slot]).to be_nil
-  end
-
-  it "provides correct package atoms for unslotted packages" do
-    expect(@versioned_provider.qatom[:pv]).to eq('1.9.3')
-  end
-
-  it "provides correct package atoms for slotted packages" do
-    expect(@versioned_slotted_provider.qatom[:pfx]).to eq('=')
-    expect(@versioned_slotted_provider.qatom[:category]).to eq('dev-lang')
-    expect(@versioned_slotted_provider.qatom[:pn]).to eq('ruby')
-    expect(@versioned_slotted_provider.qatom[:pv]).to eq('1.9.3')
-    expect(@versioned_slotted_provider.qatom[:slot]).to eq('1.9')
-  end
-
-  it "can handle search output with slots for unslotted packages" do
-    allow(@unslotted_provider).to receive(:update_eix)
-    expect(@unslotted_provider).to receive(:eix).and_return(StringIO.new(@slot_match_result))
-
-    result = @unslotted_provider.query
-    expect(result[:name]).to eq('ruby')
-    expect(result[:ensure]).to eq('2.1.8')
-    expect(result[:version_available]).to eq('2.1.9')
-  end
-
-  it "can handle search output with slots" do
-    allow(@slotted_provider).to receive(:update_eix)
-    expect(@slotted_provider).to receive(:eix).and_return(StringIO.new(@slot_match_result))
-
-    result = @slotted_provider.query
-    expect(result[:name]).to eq('ruby')
-    expect(result[:ensure]).to eq('2.1.8')
-    expect(result[:version_available]).to eq('2.1.9')
-  end
-end

data/spec/unit/provider/package/puppet_gem_spec.rb

@@ -1,130 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:puppet_gem) do
-  let(:resource) do
-    Puppet::Type.type(:package).new(
-      :name     => 'myresource',
-      :ensure   => :installed
-    )
-  end
-
-  let(:provider) do
-    provider = described_class.new
-    provider.resource = resource
-    provider
-  end
-
-  if Puppet::Util::Platform.windows?
-    let(:provider_gem_cmd) { 'C:\Program Files\Puppet Labs\Puppet\puppet\bin\gem.bat' }
-  else
-    let(:provider_gem_cmd) { '/opt/puppetlabs/puppet/bin/gem' }
-  end
-
-  custom_environment = {"HOME"=>ENV["HOME"]}
-  custom_environment['PKG_CONFIG_PATH'] = '/opt/puppetlabs/puppet/lib/pkgconfig'
-
-  let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => custom_environment} }
-
-  before :each do
-    resource.provider = provider
-    allow(described_class).to receive(:command).with(:gemcmd).and_return(provider_gem_cmd)
-    allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
-  end
-
-
-  describe '.windows_gemcmd' do
-    context 'when PUPPET_DIR is not set' do
-      before do
-        allow(ENV).to receive(:[]).and_call_original
-        allow(ENV).to receive(:[]).with('PUPPET_DIR').and_return(nil)
-        allow(Gem).to receive(:default_bindir).and_return('default_gem_bin')
-      end
-
-      it 'uses Gem.default_bindir' do
-        expected_path = File.join('default_gem_bin', 'gem.bat')
-        expect(described_class.windows_gemcmd).to eql(expected_path)
-      end
-    end
-
-    context 'when PUPPET_DIR is set' do
-      before do
-        allow(ENV).to receive(:[]).and_call_original
-        allow(ENV).to receive(:[]).with('PUPPET_DIR').and_return('puppet_dir')
-      end
-
-      it 'uses Gem.default_bindir' do
-        expected_path = File.join('puppet_dir', 'bin', 'gem.bat')
-        expect(described_class.windows_gemcmd).to eql(expected_path)
-      end
-    end
-  end
-
-  context "when installing" do
-    before :each do
-      allow(provider).to receive(:rubygem_version).and_return('1.9.9')
-    end
-
-    it "should use the path to the gem command" do
-      allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
-      expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return('')
-      provider.install
-    end
-
-    it "should not append install_options by default" do
-      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{install --no-rdoc --no-ri myresource}).and_return('')
-      provider.install
-    end
-
-    it "should allow setting an install_options parameter" do
-      resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{install --force --bindir=/usr/bin --no-rdoc --no-ri myresource}).and_return('')
-      provider.install
-    end
-  end
-
-  context "when uninstalling" do
-    it "should use the path to the gem command" do
-      allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
-      expect(described_class).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return('')
-      provider.uninstall
-    end
-
-    it "should not append uninstall_options by default" do
-      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource}).and_return('')
-      provider.uninstall
-    end
-
-    it "should allow setting an uninstall_options parameter" do
-      resource[:uninstall_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource --force --bindir=/usr/bin}).and_return('')
-      provider.uninstall
-    end
-
-    it 'should invalidate the rubygems cache' do
-      gem_source = double('gem_source')
-      allow(Puppet::Util::Autoload).to receive(:gem_source).and_return(gem_source)
-      expect(described_class).to receive(:execute_gem_command).with(provider_gem_cmd, %w{uninstall --executables --all myresource}).and_return('')
-      expect(gem_source).to receive(:clear_paths)
-      provider.uninstall
-    end
-  end
-
-  context 'calculated specificity' do
-    include_context 'provider specificity'
-
-    context 'when is not defaultfor' do
-      subject { described_class.specificity }
-      it { is_expected.to eql 1 }
-    end
-
-    context 'when is defaultfor' do
-      let(:os) { Puppet.runtime[:facter].value('os.name') }
-      subject do
-        described_class.defaultfor('os.name': os)
-        described_class.specificity
-      end
-      it { is_expected.to be > 100 }
-    end
-  end
-
-end

data/spec/unit/provider/package/puppetserver_gem_spec.rb

@@ -1,139 +0,0 @@
-require 'spec_helper'
-
-describe Puppet::Type.type(:package).provider(:puppetserver_gem) do
-  let(:resource) do
-    Puppet::Type.type(:package).new(
-      name: 'myresource',
-      ensure: :installed
-    )
-  end
-
-  let(:provider) do
-    provider = described_class.new
-    provider.resource = resource
-    provider
-  end
-
-  let(:provider_gem_cmd) { '/opt/puppetlabs/bin/puppetserver' }
-
-  custom_environment = { HOME: ENV['HOME'] }
-
-  let(:execute_options) { { failonfail: true, combine: true, custom_environment: custom_environment } }
-
-  before :each do
-    resource.provider = provider
-    allow(Puppet::Util).to receive(:which).with(provider_gem_cmd).and_return(provider_gem_cmd)
-  end
-
-  describe "#install" do
-    it "uses the path to the gem command" do
-      allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
-      expect(Puppet::Util::Execution).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return('')
-      provider.install
-    end
-
-    it "appends version if given" do
-      resource[:ensure] = ['1.2.1']
-      expect(described_class).to receive(:puppetservercmd).with(%w{gem install -v 1.2.1 --no-document myresource}).and_return('')
-      provider.install
-    end
-
-    context "with install_options" do
-      it "does not append the parameter by default" do
-        expect(described_class).to receive(:puppetservercmd).with(%w{gem install --no-document myresource}).and_return('')
-        provider.install
-      end
-
-      it "allows setting the parameter" do
-        resource[:install_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-        expect(described_class).to receive(:puppetservercmd).with(%w{gem install --force --bindir=/usr/bin --no-document myresource}).and_return('')
-        provider.install
-      end
-    end
-
-    context "with source" do
-      it "correctly sets http source" do
-        resource[:source] = 'http://rubygems.com'
-        expect(described_class).to receive(:puppetservercmd).with(%w{gem install --no-document --source http://rubygems.com myresource}).and_return('')
-        provider.install
-      end
-
-      it "correctly sets local file source" do
-        resource[:source] = 'paint-2.2.0.gem'
-        expect(described_class).to receive(:puppetservercmd).with(%w{gem install --no-document paint-2.2.0.gem}).and_return('')
-        provider.install
-      end
-
-      it "correctly sets local file source with URI scheme" do
-        resource[:source] = 'file:///root/paint-2.2.0.gem'
-        expect(described_class).to receive(:puppetservercmd).with(%w{gem install --no-document /root/paint-2.2.0.gem}).and_return('')
-        provider.install
-      end
-
-      it "raises if given a puppet URI scheme" do
-        resource[:source] = 'puppet:///paint-2.2.0.gem'
-        expect { provider.install }.to raise_error(Puppet::Error, 'puppet:// URLs are not supported as gem sources')
-      end
-
-      it "raises if given an invalid URI" do
-        resource[:source] = 'h;ttp://rubygems.com'
-        expect { provider.install }.to raise_error(Puppet::Error, /Invalid source '': bad URI\(is not URI\?\)/)
-      end
-    end
-  end
-
-  describe "#uninstall" do
-    it "uses the path to the gem command" do
-      allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
-      expect(Puppet::Util::Execution).to receive(:execute).with(be_a(Array), execute_options) { |args| expect(args[0]).to eq(provider_gem_cmd) }.and_return('')
-      provider.uninstall
-    end
-
-    context "with uninstall_options" do
-      it "does not append the parameter by default" do
-        expect(described_class).to receive(:puppetservercmd).with(%w{gem uninstall --executables --all myresource}).and_return('')
-        provider.uninstall
-      end
-
-      it "allows setting the parameter" do
-        resource[:uninstall_options] = [ '--force', {'--bindir' => '/usr/bin' } ]
-        expect(described_class).to receive(:puppetservercmd).with(%w{gem uninstall --executables --all myresource --force --bindir=/usr/bin}).and_return('')
-        provider.uninstall
-      end
-    end
-  end
-
-  describe ".gemlist" do
-    context "listing installed packages" do
-      it "uses the puppet_gem provider_command to list local gems" do
-        expected = { name: 'world_airports', provider: :puppetserver_gem, ensure: ['1.1.3'] }
-        expect(described_class).to receive(:execute_rubygems_list_command).with(['gem', 'list', '--local']).and_return(File.read(my_fixture('gem-list-local-packages')))
-        expect(described_class.gemlist({ local: true })).to include(expected)
-      end
-    end
-
-    it "appends the gem source if given" do
-      expect(described_class).to receive(:puppetservercmd).with(%w{gem list --remote --source https://rubygems.com}).and_return('')
-      described_class.gemlist({ source: 'https://rubygems.com' })
-    end
-  end
-
-  context 'calculated specificity' do
-    include_context 'provider specificity'
-
-    context 'when is not defaultfor' do
-      subject { described_class.specificity }
-      it { is_expected.to eql 1 }
-    end
-
-    context 'when is defaultfor' do
-      let(:os) {  Puppet.runtime[:facter].value('os.name') }
-      subject do
-        described_class.defaultfor('os.name': os)
-        described_class.specificity
-      end
-      it { is_expected.to be > 100 }
-    end
-  end
-
-end