puppet 7.0.0-x86-mingw32 → 7.5.0-x86-mingw32

data/spec/unit/property_spec.rb

@@ -5,6 +5,7 @@ Puppet::Type.newtype(:property_test) do
   newparam(:name, isnamevar: true)
 end
 Puppet::Type.type(:property_test).provide(:property_test) do
+  attr_accessor :foo
 end
 
 describe Puppet::Property do

data/spec/unit/provider/group/groupadd_spec.rb

@@ -198,7 +198,10 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
   end
 
   describe "#findgroup" do
-    before { allow(File).to receive(:read).with('/etc/group').and_return(content) }
+    before do
+      allow(Puppet::FileSystem).to receive(:exist?).with('/etc/group').and_return(true)
+      allow(Puppet::FileSystem).to receive(:each_line).with('/etc/group').and_yield(content)
+    end
 
     let(:content) { "sample_group_name:sample_password:sample_gid:sample_user_list" }
     let(:output) do
@@ -221,7 +224,7 @@ describe Puppet::Type.type(:group).provider(:groupadd) do
     end
 
     it "reads the group file only once per resource" do
-      expect(File).to receive(:read).with('/etc/group').once
+      expect(Puppet::FileSystem).to receive(:each_line).with('/etc/group').once
       5.times { provider.send(:findgroup, :group_name, 'sample_group_name') }
     end
   end

data/spec/unit/provider/nameservice_spec.rb

@@ -3,11 +3,28 @@ require 'puppet/provider/nameservice'
 require 'puppet/etc'
 require 'puppet_spec/character_encoding'
 
+Puppet::Type.newtype(:nameservice_dummytype) do
+  newparam(:name)
+  ensurable
+  newproperty(:foo)
+  newproperty(:bar)
+end
+
+Puppet::Type.type(:nameservice_dummytype).provide(:nameservice_dummyprovider, parent: Puppet::Provider::NameService) do
+  def posixmethod(param)
+    param
+  end
+
+  def modifycmd(param, value)
+    []
+  end
+end
+
 describe Puppet::Provider::NameService do
 
   before :each do
-    described_class.initvars
-    described_class.resource_type = faketype
+    provider.class.initvars
+    provider.class.resource_type = faketype
   end
 
   # These are values getpwent might give you
@@ -41,16 +58,12 @@ describe Puppet::Provider::NameService do
   # The provider sometimes relies on @resource for valid properties so let's
   # create a fake type with properties that match our fake struct.
   let :faketype do
-    Puppet::Type.newtype(:nameservice_dummytype) do
-      newparam(:name)
-      ensurable
-      newproperty(:foo)
-      newproperty(:bar)
-    end
+    Puppet::Type.type(:nameservice_dummytype)
   end
 
   let :provider do
-    described_class.new(:name => 'bob', :foo => 'fooval', :bar => 'barval')
+    Puppet::Type.type(:nameservice_dummytype).provider(:nameservice_dummyprovider)
+      .new(:name => 'bob', :foo => 'fooval', :bar => 'barval')
   end
 
   let :resource do
@@ -91,61 +104,61 @@ describe Puppet::Provider::NameService do
 
   describe "#options" do
     it "should add options for a valid property" do
-      described_class.options :foo, :key1 => 'val1', :key2 => 'val2'
-      described_class.options :bar, :key3 => 'val3'
-      expect(described_class.option(:foo, :key1)).to eq('val1')
-      expect(described_class.option(:foo, :key2)).to eq('val2')
-      expect(described_class.option(:bar, :key3)).to eq('val3')
+      provider.class.options :foo, :key1 => 'val1', :key2 => 'val2'
+      provider.class.options :bar, :key3 => 'val3'
+      expect(provider.class.option(:foo, :key1)).to eq('val1')
+      expect(provider.class.option(:foo, :key2)).to eq('val2')
+      expect(provider.class.option(:bar, :key3)).to eq('val3')
     end
 
     it "should raise an error for an invalid property" do
-      expect { described_class.options :baz, :key1 => 'val1' }.to raise_error(
+      expect { provider.class.options :baz, :key1 => 'val1' }.to raise_error(
         Puppet::Error, 'baz is not a valid attribute for nameservice_dummytype')
     end
   end
 
   describe "#option" do
     it "should return the correct value" do
-      described_class.options :foo, :key1 => 'val1', :key2 => 'val2'
-      expect(described_class.option(:foo, :key2)).to eq('val2')
+      provider.class.options :foo, :key1 => 'val1', :key2 => 'val2'
+      expect(provider.class.option(:foo, :key2)).to eq('val2')
     end
 
     it "should symbolize the name first" do
-      described_class.options :foo, :key1 => 'val1', :key2 => 'val2'
-      expect(described_class.option('foo', :key2)).to eq('val2')
+      provider.class.options :foo, :key1 => 'val1', :key2 => 'val2'
+      expect(provider.class.option('foo', :key2)).to eq('val2')
     end
 
     it "should return nil if no option has been specified earlier" do
-      expect(described_class.option(:foo, :key2)).to be_nil
+      expect(provider.class.option(:foo, :key2)).to be_nil
     end
 
     it "should return nil if no option for that property has been specified earlier" do
-      described_class.options :bar, :key2 => 'val2'
-      expect(described_class.option(:foo, :key2)).to be_nil
+      provider.class.options :bar, :key2 => 'val2'
+      expect(provider.class.option(:foo, :key2)).to be_nil
     end
 
     it "should return nil if no matching key can be found for that property" do
-      described_class.options :foo, :key3 => 'val2'
-      expect(described_class.option(:foo, :key2)).to be_nil
+      provider.class.options :foo, :key3 => 'val2'
+      expect(provider.class.option(:foo, :key2)).to be_nil
     end
   end
 
   describe "#section" do
     it "should raise an error if resource_type has not been set" do
-      expect(described_class).to receive(:resource_type).and_return(nil)
-      expect { described_class.section }.to raise_error Puppet::Error, 'Cannot determine Etc section without a resource type'
+      expect(provider.class).to receive(:resource_type).and_return(nil)
+      expect { provider.class.section }.to raise_error Puppet::Error, 'Cannot determine Etc section without a resource type'
     end
 
     # the return values are hard coded so I am using types that actually make
     # use of the nameservice provider
     it "should return pw for users" do
-      described_class.resource_type = Puppet::Type.type(:user)
-      expect(described_class.section).to eq('pw')
+      provider.class.resource_type = Puppet::Type.type(:user)
+      expect(provider.class.section).to eq('pw')
     end
 
     it "should return gr for groups" do
-      described_class.resource_type = Puppet::Type.type(:group)
-      expect(described_class.section).to eq('gr')
+      provider.class.resource_type = Puppet::Type.type(:group)
+      expect(provider.class.section).to eq('gr')
     end
   end
 
@@ -156,7 +169,7 @@ describe Puppet::Provider::NameService do
       # encoding
       allow(Etc).to receive(:getpwent).and_return(*utf_8_mixed_users)
       result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
-        described_class.instances
+        provider.class.instances
       end
       expect(result.map(&:name)).to eq(
         [
@@ -171,7 +184,7 @@ describe Puppet::Provider::NameService do
     it "should have object names in their original encoding/bytes if they would not be valid UTF-8" do
       allow(Etc).to receive(:getpwent).and_return(*latin_1_mixed_users)
       result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::ISO_8859_1) do
-        described_class.instances
+        provider.class.instances
       end
       expect(result.map(&:name)).to eq(
         [
@@ -186,40 +199,40 @@ describe Puppet::Provider::NameService do
     it "should pass the Puppet::Etc :canonical_name Struct member to the constructor" do
       users = [ Struct::Passwd.new(invalid_utf_8_jose, invalid_utf_8_jose, 1002, 2000), nil ]
       allow(Etc).to receive(:getpwent).and_return(*users)
-      expect(described_class).to receive(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
-      described_class.instances
+      expect(provider.class).to receive(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
+      provider.class.instances
     end
   end
 
   describe "validate" do
     it "should pass if no check is registered at all" do
-      expect { described_class.validate(:foo, 300) }.to_not raise_error
-      expect { described_class.validate('foo', 300) }.to_not raise_error
+      expect { provider.class.validate(:foo, 300) }.to_not raise_error
+      expect { provider.class.validate('foo', 300) }.to_not raise_error
     end
 
     it "should pass if no check for that property is registered" do
-      described_class.verify(:bar, 'Must be 100') { |val| val == 100 }
-      expect { described_class.validate(:foo, 300) }.to_not raise_error
-      expect { described_class.validate('foo', 300) }.to_not raise_error
+      provider.class.verify(:bar, 'Must be 100') { |val| val == 100 }
+      expect { provider.class.validate(:foo, 300) }.to_not raise_error
+      expect { provider.class.validate('foo', 300) }.to_not raise_error
     end
 
     it "should pass if the value is valid" do
-      described_class.verify(:foo, 'Must be 100') { |val| val == 100 }
-      expect { described_class.validate(:foo, 100) }.to_not raise_error
-      expect { described_class.validate('foo', 100) }.to_not raise_error
+      provider.class.verify(:foo, 'Must be 100') { |val| val == 100 }
+      expect { provider.class.validate(:foo, 100) }.to_not raise_error
+      expect { provider.class.validate('foo', 100) }.to_not raise_error
     end
 
     it "should raise an error if the value is invalid" do
-      described_class.verify(:foo, 'Must be 100') { |val| val == 100 }
-      expect { described_class.validate(:foo, 200) }.to raise_error(ArgumentError, 'Invalid value 200: Must be 100')
-      expect { described_class.validate('foo', 200) }.to raise_error(ArgumentError, 'Invalid value 200: Must be 100')
+      provider.class.verify(:foo, 'Must be 100') { |val| val == 100 }
+      expect { provider.class.validate(:foo, 200) }.to raise_error(ArgumentError, 'Invalid value 200: Must be 100')
+      expect { provider.class.validate('foo', 200) }.to raise_error(ArgumentError, 'Invalid value 200: Must be 100')
     end
   end
 
   describe "getinfo" do
     before :each do
       # with section=foo we'll call Etc.getfoonam instead of getpwnam or getgrnam
-      allow(described_class).to receive(:section).and_return('foo')
+      allow(provider.class).to receive(:section).and_return('foo')
       resource # initialize the resource so our provider has a @resource instance variable
     end
 
@@ -239,13 +252,13 @@ describe Puppet::Provider::NameService do
     # overriding to UTF-8, in @canonical_name for querying that state on disk
     # again if needed
     it "should use the instance's @canonical_name to query the system" do
-      provider_instance = described_class.new(:name => 'foo', :canonical_name => 'original_foo', :ensure => :present)
+      provider_instance = provider.class.new(:name => 'foo', :canonical_name => 'original_foo', :ensure => :present)
       expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'original_foo')
       provider_instance.getinfo(true)
     end
 
     it "should use the instance's name instead of canonical_name if not supplied during instantiation" do
-      provider_instance = described_class.new(:name => 'foo', :ensure => :present)
+      provider_instance = provider.class.new(:name => 'foo', :ensure => :present)
       expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'foo')
       provider_instance.getinfo(true)
     end
@@ -253,16 +266,6 @@ describe Puppet::Provider::NameService do
 
   describe "info2hash" do
     it "should return a hash with all properties" do
-      # we have to have an implementation of posixmethod which has to
-      # convert a propertyname (e.g. comment) into a fieldname of our
-      # Struct (e.g. gecos). I do not want to test posixmethod here so
-      # let's fake an implementation which does not do any translation. We
-      # expect two method invocations because info2hash calls the method
-      # twice if the Struct responds to the propertyname (our fake Struct
-      # provides values for :foo and :bar) TODO: Fix that
-      expect(provider).to receive(:posixmethod).with(:foo).and_return(:foo).twice
-      expect(provider).to receive(:posixmethod).with(:bar).and_return(:bar).twice
-      expect(provider).to receive(:posixmethod).with(:ensure).and_return(:ensure)
       expect(provider.info2hash(fakeetcobject)).to eq({ :foo => 'fooval', :bar => 'barval' })
     end
   end
@@ -273,7 +276,7 @@ describe Puppet::Provider::NameService do
     end
 
     it "should return the munged value otherwise" do
-      described_class.options(:foo, :munge => proc { |x| x*2 })
+      provider.class.options(:foo, :munge => proc { |x| x*2 })
       expect(provider.munge(:foo, 100)).to eq(200)
     end
   end
@@ -284,7 +287,7 @@ describe Puppet::Provider::NameService do
     end
 
     it "should return the unmunged value otherwise" do
-      described_class.options(:foo, :unmunge => proc { |x| x/2 })
+      provider.class.options(:foo, :unmunge => proc { |x| x/2 })
       expect(provider.unmunge(:foo, 200)).to eq(100)
     end
   end
@@ -302,15 +305,13 @@ describe Puppet::Provider::NameService do
   end
 
   describe "get" do
-    before(:each) {described_class.resource_type = faketype }
-
     it "should return the correct getinfo value" do
       expect(provider).to receive(:getinfo).with(false).and_return(:foo => 'fooval', :bar => 'barval')
       expect(provider.get(:bar)).to eq('barval')
     end
 
     it "should unmunge the value first" do
-      described_class.options(:bar, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
+      provider.class.options(:bar, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
       expect(provider).to receive(:getinfo).with(false).and_return(:foo => 200, :bar => 500)
       expect(provider.get(:bar)).to eq(250)
     end
@@ -325,7 +326,7 @@ describe Puppet::Provider::NameService do
   describe "set" do
     before :each do
       resource # initialize resource so our provider has a @resource object
-      described_class.verify(:foo, 'Must be 100') { |val| val == 100 }
+      provider.class.verify(:foo, 'Must be 100') { |val| val == 100 }
     end
 
     it "should raise an error on invalid values" do
@@ -339,7 +340,7 @@ describe Puppet::Provider::NameService do
     end
 
     it "should munge the value first" do
-      described_class.options(:foo, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
+      provider.class.options(:foo, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
       expect(provider).to receive(:modifycmd).with(:foo, 200).and_return(['/bin/modify', '-f', '200' ])
       expect(provider).to receive(:execute).with(['/bin/modify', '-f', '200'], hash_including(custom_environment: {}))
       provider.set(:foo, 100)

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

@@ -11,9 +11,7 @@ describe Puppet::Type.type(:package).provider(:apt) do
   end
 
   let(:provider) do
-    provider = subject()
-    provider.resource = resource
-    provider
+    resource.provider
   end
 
   it "should be the default provider on :osfamily => Debian" do
@@ -88,7 +86,7 @@ Version table:
 
   describe ".instances" do
     before do
-      allow(Puppet::Type::Package::ProviderDpkg).to receive(:instances).and_return([resource])
+      allow(Puppet::Type::Package::ProviderDpkg).to receive(:instances).and_return([provider])
     end
 
     context "when package is manual marked" do
@@ -97,8 +95,7 @@ Version table:
       end
 
       it 'sets mark to manual' do
-        expect(resource).to receive(:mark=).with(:manual)
-        described_class.instances
+        expect(described_class.instances.map(&:mark)).to eq([:manual])
       end
     end
 
@@ -108,8 +105,7 @@ Version table:
       end
 
       it 'does not set mark to manual' do
-        expect(resource).not_to receive(:mark=).with(:manual)
-        described_class.instances
+        expect(described_class.instances.map(&:mark)).to eq([nil])
       end
     end
   end
@@ -119,24 +115,12 @@ Version table:
       allow(provider).to receive(:dpkgquery).and_return("name: #{resource.name}" )
     end
 
-    context "when package is manual marked" do
-      before do
-        allow(described_class).to receive(:aptmark).with('showmanual').and_return("#{resource.name}\n")
-      end
-
-      it 'sets mark to manual' do
-        result = provider.query
-        expect(result[:mark]).to eql(:manual)
-      end
-    end
-
-    context 'when package is not manual marked ' do
-      before do
-        allow(described_class).to receive(:aptmark).with('showmanual').and_return('')
-      end
 
+    context 'when package is not installed on the system' do
       it 'does not set mark to manual' do
         result = provider.query
+
+        expect(described_class).not_to receive(:aptmark)
         expect(result[:mark]).to be_nil
       end
     end
@@ -293,5 +277,26 @@ Version table:
 
       provider.install
     end
+
+    it "should install using the source attribute if present" do
+      resource[:ensure] = :installed
+      resource[:source] = '/my/local/package/file'
+
+      expect(provider).to receive(:aptget).with(any_args, :install, resource[:source])
+      expect(provider).to receive(:properties).and_return({:mark => :none})
+
+      provider.install
+    end
+
+    it "should install specific version using the source attribute if present" do
+      resource[:ensure] = '1.2.3'
+      resource[:source] = '/my/local/package/file'
+
+      expect(provider).to receive(:aptget).with(any_args, :install, resource[:source])
+      expect(provider).to receive(:properties).and_return({:mark => :none})
+      expect(provider).to receive(:query).and_return({:ensure => '1.2.3'})
+
+      provider.install
+    end
   end
 end

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

@@ -13,7 +13,7 @@ describe Puppet::Type.type(:package).provider(:aptitude) do
 
     before do
       allow(Puppet::Util).to receive(:which).with('/usr/bin/dpkg-query').and_return(dpkgquery_path)
-      allow(described_class).to receive(:aptmark).with('showmanual').and_return("")
+      allow(described_class).to receive(:aptmark).with('showmanual', 'faff').and_return("")
     end
 
     { :absent   => "deinstall ok config-files faff 1.2.3-1\n",

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

@@ -1,17 +1,18 @@
 require 'spec_helper'
 require 'puppet/provider/package'
 
+Puppet::Type.type(:package).provide(:test_base_provider, parent: Puppet::Provider::Package) do
+  def query; end
+end
+
 describe Puppet::Provider::Package do
+  let(:provider) {  Puppet::Type.type(:package).provider(:test_base_provider).new }
+
   it 'returns absent for uninstalled packages when not purgeable' do
-    provider = Puppet::Provider::Package.new
-    expect(provider).to receive(:query).and_return(nil)
-    expect(provider.class).to receive(:feature?).with(:purgeable).and_return(false)
     expect(provider.properties[:ensure]).to eq(:absent)
   end
 
   it 'returns purged for uninstalled packages when purgeable' do
-    provider = Puppet::Provider::Package.new
-    expect(provider).to receive(:query).and_return(nil)
     expect(provider.class).to receive(:feature?).with(:purgeable).and_return(true)
     expect(provider.properties[:ensure]).to eq(:purged)
   end

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

@@ -32,10 +32,12 @@ describe Puppet::Type.type(:package).provider(:pacman) do
     end
 
     it "should call yaourt to install the right package quietly when yaourt is installed" do
-      allow(described_class).to receive(:yaourt?).and_return(true)
-      args = ['--noconfirm', '--needed', '--noprogressbar', '-S', resource[:name]]
-      expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
-      provider.install
+      without_partial_double_verification do
+        allow(described_class).to receive(:yaourt?).and_return(true)
+        args = ['--noconfirm', '--needed', '--noprogressbar', '-S', resource[:name]]
+        expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
+        provider.install
+      end
     end
 
     it "should raise an Puppet::Error if the installation failed" do
@@ -74,10 +76,12 @@ describe Puppet::Type.type(:package).provider(:pacman) do
       end
 
       it "should call yaourt to install the right package quietly when yaourt is installed" do
-        expect(described_class).to receive(:yaourt?).and_return(true)
-        args = ['--noconfirm', '--needed', '--noprogressbar', '-x', '--arg=value', '-S', resource[:name]]
-        expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
-        provider.install
+        without_partial_double_verification do
+          expect(described_class).to receive(:yaourt?).and_return(true)
+          args = ['--noconfirm', '--needed', '--noprogressbar', '-x', '--arg=value', '-S', resource[:name]]
+          expect(provider).to receive(:yaourt).at_least(:once).with(*args).and_return('')
+          provider.install
+        end
       end
     end
 
@@ -172,10 +176,12 @@ describe Puppet::Type.type(:package).provider(:pacman) do
     end
 
     it "should call yaourt to remove the right package quietly" do
-      allow(described_class).to receive(:yaourt?).and_return(true)
-      args = ["--noconfirm", "--noprogressbar", "-R", resource[:name]]
-      expect(provider).to receive(:yaourt).with(*args)
-      provider.uninstall
+      without_partial_double_verification do
+        allow(described_class).to receive(:yaourt?).and_return(true)
+        args = ["--noconfirm", "--noprogressbar", "-R", resource[:name]]
+        expect(provider).to receive(:yaourt).with(*args)
+        provider.uninstall
+      end
     end
 
     it "adds any uninstall_options" do