puppet 6.29.0 → 7.0.0

data/spec/unit/provider/nameservice_spec.rb

@@ -3,28 +3,11 @@ 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
-    provider.class.initvars
-    provider.class.resource_type = faketype
+    described_class.initvars
+    described_class.resource_type = faketype
   end
 
   # These are values getpwent might give you
@@ -58,12 +41,16 @@ 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.type(:nameservice_dummytype)
+    Puppet::Type.newtype(:nameservice_dummytype) do
+      newparam(:name)
+      ensurable
+      newproperty(:foo)
+      newproperty(:bar)
+    end
   end
 
   let :provider do
-    Puppet::Type.type(:nameservice_dummytype).provider(:nameservice_dummyprovider)
-      .new(:name => 'bob', :foo => 'fooval', :bar => 'barval')
+    described_class.new(:name => 'bob', :foo => 'fooval', :bar => 'barval')
   end
 
   let :resource do
@@ -104,118 +91,61 @@ describe Puppet::Provider::NameService do
 
   describe "#options" do
     it "should add options for a valid property" do
-      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')
+      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')
     end
 
     it "should raise an error for an invalid property" do
-      expect { provider.class.options :baz, :key1 => 'val1' }.to raise_error(
+      expect { described_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
-      provider.class.options :foo, :key1 => 'val1', :key2 => 'val2'
-      expect(provider.class.option(:foo, :key2)).to eq('val2')
+      described_class.options :foo, :key1 => 'val1', :key2 => 'val2'
+      expect(described_class.option(:foo, :key2)).to eq('val2')
     end
 
     it "should symbolize the name first" do
-      provider.class.options :foo, :key1 => 'val1', :key2 => 'val2'
-      expect(provider.class.option('foo', :key2)).to eq('val2')
+      described_class.options :foo, :key1 => 'val1', :key2 => 'val2'
+      expect(described_class.option('foo', :key2)).to eq('val2')
     end
 
     it "should return nil if no option has been specified earlier" do
-      expect(provider.class.option(:foo, :key2)).to be_nil
+      expect(described_class.option(:foo, :key2)).to be_nil
     end
 
     it "should return nil if no option for that property has been specified earlier" do
-      provider.class.options :bar, :key2 => 'val2'
-      expect(provider.class.option(:foo, :key2)).to be_nil
+      described_class.options :bar, :key2 => 'val2'
+      expect(described_class.option(:foo, :key2)).to be_nil
     end
 
     it "should return nil if no matching key can be found for that property" do
-      provider.class.options :foo, :key3 => 'val2'
-      expect(provider.class.option(:foo, :key2)).to be_nil
+      described_class.options :foo, :key3 => 'val2'
+      expect(described_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(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'
+      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'
     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
-      provider.class.resource_type = Puppet::Type.type(:user)
-      expect(provider.class.section).to eq('pw')
-    end
-
-    it "should return gr for groups" do
-      provider.class.resource_type = Puppet::Type.type(:group)
-      expect(provider.class.section).to eq('gr')
-    end
-  end
-
-  describe "#listbyname" do
-    it "should be deprecated" do
-      expect(Puppet).to receive(:deprecation_warning).with(/listbyname is deprecated/)
-      described_class.listbyname
-    end
-
-    it "should return a list of users if resource_type is user" do
       described_class.resource_type = Puppet::Type.type(:user)
-      expect(Puppet::Etc).to receive(:setpwent)
-      allow(Puppet::Etc).to receive(:getpwent).and_return(*users)
-      expect(Puppet::Etc).to receive(:endpwent)
-      expect(described_class.listbyname).to eq(%w{root foo})
+      expect(described_class.section).to eq('pw')
     end
 
-    context "encoding handling" do
-      described_class.resource_type = Puppet::Type.type(:user)
-
-      # These two tests simulate an environment where there are two users with
-      # the same name on disk, but each name is stored on disk in a different
-      # encoding
-      it "should return names with invalid byte sequences replaced with '?'" do
-        allow(Etc).to receive(:getpwent).and_return(*utf_8_mixed_users)
-        expect(invalid_utf_8_jose).to_not be_valid_encoding
-        result = PuppetSpec::CharacterEncoding.with_external_encoding(Encoding::UTF_8) do
-          described_class.listbyname
-        end
-        expect(result).to eq(['root', 'foo', utf_8_jose, escaped_utf_8_jose])
-      end
-
-      it "should return 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.listbyname
-        end
-        expect(result).to eq(['root'.force_encoding(Encoding::UTF_8), 'foo'.force_encoding(Encoding::UTF_8), utf_8_jose, valid_latin1_jose])
-      end
-    end
-
-    it "should return a list of groups if resource_type is group", :unless => Puppet::Util::Platform.windows? do
+    it "should return gr for groups" do
       described_class.resource_type = Puppet::Type.type(:group)
-      expect(Puppet::Etc).to receive(:setgrent)
-      allow(Puppet::Etc).to receive(:getgrent).and_return(*groups)
-      expect(Puppet::Etc).to receive(:endgrent)
-      expect(described_class.listbyname).to eq(%w{root bin})
-    end
-
-    it "should yield if a block given" do
-      yield_results = []
-      described_class.resource_type = Puppet::Type.type(:user)
-      expect(Puppet::Etc).to receive(:setpwent)
-      allow(Puppet::Etc).to receive(:getpwent).and_return(*users)
-      expect(Puppet::Etc).to receive(:endpwent)
-      described_class.listbyname {|x| yield_results << x }
-      expect(yield_results).to eq(%w{root foo})
+      expect(described_class.section).to eq('gr')
     end
   end
 
@@ -226,7 +156,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
-        provider.class.instances
+        described_class.instances
       end
       expect(result.map(&:name)).to eq(
         [
@@ -241,7 +171,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
-        provider.class.instances
+        described_class.instances
       end
       expect(result.map(&:name)).to eq(
         [
@@ -256,40 +186,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(provider.class).to receive(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
-      provider.class.instances
+      expect(described_class).to receive(:new).with(:name => escaped_utf_8_jose, :canonical_name => invalid_utf_8_jose, :ensure => :present)
+      described_class.instances
     end
   end
 
   describe "validate" do
     it "should pass if no check is registered at all" do
-      expect { provider.class.validate(:foo, 300) }.to_not raise_error
-      expect { provider.class.validate('foo', 300) }.to_not raise_error
+      expect { described_class.validate(:foo, 300) }.to_not raise_error
+      expect { described_class.validate('foo', 300) }.to_not raise_error
     end
 
     it "should pass if no check for that property is registered" do
-      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
+      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
     end
 
     it "should pass if the value is valid" do
-      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
+      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
     end
 
     it "should raise an error if the value is invalid" do
-      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')
+      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')
     end
   end
 
   describe "getinfo" do
     before :each do
       # with section=foo we'll call Etc.getfoonam instead of getpwnam or getgrnam
-      allow(provider.class).to receive(:section).and_return('foo')
+      allow(described_class).to receive(:section).and_return('foo')
       resource # initialize the resource so our provider has a @resource instance variable
     end
 
@@ -309,13 +239,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 = provider.class.new(:name => 'foo', :canonical_name => 'original_foo', :ensure => :present)
+      provider_instance = described_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 = provider.class.new(:name => 'foo', :ensure => :present)
+      provider_instance = described_class.new(:name => 'foo', :ensure => :present)
       expect(Puppet::Etc).to receive(:send).with(:getfoonam, 'foo')
       provider_instance.getinfo(true)
     end
@@ -323,6 +253,16 @@ 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
@@ -333,7 +273,7 @@ describe Puppet::Provider::NameService do
     end
 
     it "should return the munged value otherwise" do
-      provider.class.options(:foo, :munge => proc { |x| x*2 })
+      described_class.options(:foo, :munge => proc { |x| x*2 })
       expect(provider.munge(:foo, 100)).to eq(200)
     end
   end
@@ -344,7 +284,7 @@ describe Puppet::Provider::NameService do
     end
 
     it "should return the unmunged value otherwise" do
-      provider.class.options(:foo, :unmunge => proc { |x| x/2 })
+      described_class.options(:foo, :unmunge => proc { |x| x/2 })
       expect(provider.unmunge(:foo, 200)).to eq(100)
     end
   end
@@ -362,13 +302,15 @@ 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
-      provider.class.options(:bar, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
+      described_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
@@ -383,7 +325,7 @@ describe Puppet::Provider::NameService do
   describe "set" do
     before :each do
       resource # initialize resource so our provider has a @resource object
-      provider.class.verify(:foo, 'Must be 100') { |val| val == 100 }
+      described_class.verify(:foo, 'Must be 100') { |val| val == 100 }
     end
 
     it "should raise an error on invalid values" do
@@ -397,7 +339,7 @@ describe Puppet::Provider::NameService do
     end
 
     it "should munge the value first" do
-      provider.class.options(:foo, :munge => proc { |x| x*2}, :unmunge => proc {|x| x/2})
+      described_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,7 +11,9 @@ describe Puppet::Type.type(:package).provider(:apt) do
   end
 
   let(:provider) do
-    resource.provider
+    provider = subject()
+    provider.resource = resource
+    provider
   end
 
   it "should be the default provider on :osfamily => Debian" do
@@ -86,7 +88,7 @@ Version table:
 
   describe ".instances" do
     before do
-      allow(Puppet::Type::Package::ProviderDpkg).to receive(:instances).and_return([provider])
+      allow(Puppet::Type::Package::ProviderDpkg).to receive(:instances).and_return([resource])
     end
 
     context "when package is manual marked" do
@@ -95,7 +97,8 @@ Version table:
       end
 
       it 'sets mark to manual' do
-        expect(described_class.instances.map(&:mark)).to eq([:manual])
+        expect(resource).to receive(:mark=).with(:manual)
+        described_class.instances
       end
     end
 
@@ -105,7 +108,8 @@ Version table:
       end
 
       it 'does not set mark to manual' do
-        expect(described_class.instances.map(&:mark)).to eq([nil])
+        expect(resource).not_to receive(:mark=).with(:manual)
+        described_class.instances
       end
     end
   end
@@ -115,12 +119,24 @@ 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
 
-    context 'when package is not installed on the system' do
-      it 'does not set mark to manual' do
+      it 'sets mark to manual' do
         result = provider.query
+        expect(result[:mark]).to eql(:manual)
+      end
+    end
 
-        expect(described_class).not_to receive(:aptmark)
+    context 'when package is not manual marked ' do
+      before do
+        allow(described_class).to receive(:aptmark).with('showmanual').and_return('')
+      end
+
+      it 'does not set mark to manual' do
+        result = provider.query
         expect(result[:mark]).to be_nil
       end
     end
@@ -277,26 +293,5 @@ 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', 'faff').and_return("")
+      allow(described_class).to receive(:aptmark).with('showmanual').and_return("")
     end
 
     { :absent   => "deinstall ok config-files faff 1.2.3-1\n",

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

@@ -1,18 +1,17 @@
 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/dnfmodule_spec.rb

@@ -123,7 +123,7 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
         provider.install
       end
 
-      it "should just enable the module if it has no default profile(missing groups or modules)" do
+      it "should just enable the module if it has no default profile" do
         dnf_exception = Puppet::ExecutionFailure.new("Error: Problems in request:\nmissing groups or modules: #{resource[:name]}")
         allow(provider).to receive(:execute).with(array_including('install')).and_raise(dnf_exception)
         resource[:ensure] = :present
@@ -132,15 +132,6 @@ describe Puppet::Type.type(:package).provider(:dnfmodule) do
         provider.install
       end
 
-      it "should just enable the module if it has no default profile(broken groups or modules)" do
-        dnf_exception = Puppet::ExecutionFailure.new("Error: Problems in request:\nbroken groups or modules: #{resource[:name]}")
-        allow(provider).to receive(:execute).with(array_including('install')).and_raise(dnf_exception)
-        resource[:ensure] = :present
-        expect(provider).to receive(:execute).with(array_including('install')).ordered
-        expect(provider).to receive(:execute).with(array_including('enable')).ordered
-        provider.install
-      end
-
       it "should just enable the module if enable_only = true" do
         resource[:ensure] = :present
         resource[:enable_only] = true

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

@@ -392,39 +392,13 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
       allow(Tempfile).to receive(:open).and_yield(tempfile)
     end
 
-    it "installs first if package is not present and ensure holding" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(true)
-      expect(provider).to receive(:install).once
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
-    end
-
-    it "skips install new package if hold is true" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(true)
-      expect(provider).to receive(:install).once
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
-    end
-
-    it "skips install new package if package is allready installed" do
-      allow(provider).to receive(:execute)
-      allow(provider).to receive(:package_not_installed?).and_return(false)
-      expect(provider).not_to receive(:install)
-      expect(provider).to receive(:hold)
-      provider.deprecated_hold
-    end
-
     it "executes dpkg --set-selections when holding" do
-      allow(provider).to receive(:package_not_installed?).and_return(false)
       allow(provider).to receive(:install)
       expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
     end
 
     it "executes dpkg --set-selections when unholding" do
-      allow(provider).to receive(:package_not_installed?).and_return(false)
       allow(provider).to receive(:install)
       expect(provider).to receive(:execute).with([:dpkg, '--set-selections'], {:failonfail => false, :combine => false, :stdinfile => tempfile.path}).once
       provider.hold
@@ -467,26 +441,4 @@ describe Puppet::Type.type(:package).provider(:dpkg), unless: Puppet::Util::Plat
     provider.purge
   end
 
-  context "package_not_installed?" do
-    context "allow_virtual false" do
-        before do
-          allow(resource).to receive(:allow_virtual?).and_return(false)
-        end
-
-      it "returns true if package is not found" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_raise(Puppet::ExecutionFailure.new("eh"))
-        expect(provider.package_not_installed?).to eq(true)
-      end
-
-      it "returns true if package is not installed" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("unknown ok not-installed #{resource_name}")
-        expect(provider.package_not_installed?).to eq(true)
-      end
-
-      it "returns false if package is installed" do
-        expect(provider).to receive(:dpkgquery).with("-W", "--showformat", "'${Status} ${Package} ${Version}\\n'", resource_name).and_return("install ok installed resource_name 1.2.3")
-        expect(provider.package_not_installed?).to eq(false)
-      end
-    end
-  end
 end

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

@@ -12,6 +12,10 @@ context Puppet::Type.type(:package).provider(:gem) do
   let(:provider_gem_cmd) { '/provider/gem' }
   let(:execute_options) { {:failonfail => true, :combine => true, :custom_environment => {"HOME"=>ENV["HOME"]}} }
 
+  before do
+    allow(Puppet::Util::Platform).to receive(:windows?).and_return(false)
+  end
+
   context 'installing myresource' do
     let(:resource) do
       Puppet::Type.type(:package).new(
@@ -36,6 +40,34 @@ context Puppet::Type.type(:package).provider(:gem) do
         allow(provider).to receive(:rubygem_version).and_return('1.9.9')
       end
 
+      context 'on windows' do
+        let(:path) do
+          "C:\\Program Files\\Puppet Labs\\Puppet\\puppet\\bin;C:\\Program Files\\Puppet Labs\\Puppet\\bin;C:\\Ruby26-x64\\bin;C:\\Windows\\system32\\bin"
+        end
+
+        let(:expected_path) do
+          "C:\\Program Files\\Puppet Labs\\Puppet\\bin;C:\\Ruby26-x64\\bin;C:\\Windows\\system32\\bin"
+        end
+
+        before do
+          allow(Puppet::Util::Platform).to receive(:windows?).and_return(true)
+          allow(Puppet::Util).to receive(:get_env)
+          allow(Puppet::Util).to receive(:get_env).with('PATH').and_return(path)
+          allow(described_class).to receive(:validate_command).with(provider_gem_cmd)
+          stub_const('::File::PATH_SEPARATOR', ';')
+        end
+
+        it 'removes puppet/bin from PATH' do
+          expect(described_class).to receive(:execute) \
+            .with(
+              anything,
+              hash_including(custom_environment: hash_including(PATH: expected_path))
+            )
+            .and_return("")
+          provider.install
+        end
+      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("")
@@ -442,7 +474,7 @@ context Puppet::Type.type(:package).provider(:gem) do
     end
 
     context 'when is defaultfor' do
-      let(:os) {  Puppet.runtime[:facter].value(:operatingsystem) }
+      let(:os) {  Facter.value(:operatingsystem) }
       subject do
         described_class.defaultfor(operatingsystem: os)
         described_class.specificity