puppet 5.5.7-x64-mingw32 → 5.5.8-x64-mingw32

data/spec/unit/provider/user/useradd_spec.rb

@@ -138,10 +138,10 @@ describe Puppet::Type.type(:user).provider(:useradd) do
         provider.create
       end
 
-      it "should not use -e with luseradd, should call lusermod with -e after luseradd when expiry is set" do
+      it "should not use -e with luseradd, should call usermod with -e after luseradd when expiry is set" do
         resource[:expiry] = '2038-01-24'
         provider.expects(:execute).with(all_of(includes('/usr/sbin/luseradd'), Not(includes('-e'))), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
-        provider.expects(:execute).with(all_of(includes('/usr/sbin/lusermod'), includes('-e')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
+        provider.expects(:execute).with(all_of(includes('/usr/sbin/usermod'), includes('-e')), has_entry(:custom_environment, has_key('LIBUSER_CONF')))
         provider.create
       end
 

data/spec/unit/type/group_spec.rb

@@ -2,21 +2,8 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:group) do
-  let(:mock_group_provider) do
-    described_class.provide(:mock_group_provider) do
-      has_features :manages_members
-      mk_resource_methods
-      def create; end
-      def delete; end
-      def exists?; get(:ensure) != :absent; end
-      def flush; end
-      def self.instances; []; end
-    end
-  end
-
-  before(:each) do
+  before do
     @class = Puppet::Type.type(:group)
-    described_class.stubs(:defaultprovider).returns mock_group_provider
   end
 
   it "should have a system_groups feature" do
@@ -83,108 +70,31 @@ describe Puppet::Type.type(:group) do
     expect(type.exists?).to eq(true)
   end
 
-  describe "when managing members" do
-    def stub_property(resource_hash)
-      described_class.new(resource_hash).property(:members)
-    end
-
-    describe "validation" do
-      it "raises an error for a non-String value" do
-        expect {
-          described_class.new(:name => 'foo', :members => true)
-        }.to raise_error(Puppet::Error)
-      end
-
-      it "raises an error for an array value containing a non-String element" do
-        expect {
-          described_class.new(:name => 'foo', :members => [ true, 'foo' ])
-        }.to raise_error(Puppet::Error)
-      end
-
-      it "raises an error when the members are specified as UIDs instead of usernames" do
-        expect {
-          described_class.new(:name => 'foo', :members => [ '123', '456' ])
-        }.to raise_error(Puppet::Error)
-      end
-
-      it "raises an error when an empty string is passed for a member's username" do
-        expect {
-          described_class.new(:name => 'foo', :members => [ 'foo', '' ])
-        }.to raise_error(Puppet::Error)
-      end
-
-      it "passes for a single member" do
-        expect {
-          described_class.new(:name => 'foo', :members => 'foo')
-        }.to_not raise_error
-      end
+  describe "should delegate :members implementation to the provider:"  do
 
-      it "passes for a member whose username has a number" do
-        expect {
-          described_class.new(:name => 'foo', :members => 'foo123')
-        }.to_not raise_error
-      end
+    let (:provider) do
+      @class.provide(:testing) do
+        has_features :manages_members
 
-      it "passes for an array of members" do
-        expect {
-          described_class.new(:name => 'foo', :members => [ 'foo', 'bar' ])
-        }.to_not raise_error
-      end
-
-      it "passes for a comma-separated list of members" do
-        expect {
-          described_class.new(:name => 'foo', :members => 'foo,bar')
-        }.to_not raise_error
+        def members
+          []
+        end
       end
     end
+    let (:provider_instance) { provider.new }
+    let (:type) { @class.new(:name => "group", :provider => provider_instance, :members => ['user1']) }
 
-    describe "#inclusive?" do
-      it "returns false when auth_membership == false" do
-        members_property = stub_property(
-          :name => 'foo',
-          :auth_membership => false,
-          :members => []
-        )
-
-        expect(members_property.inclusive?).to be false
-      end
-
-      it "returns true when auth_membership == true" do
-        members_property = stub_property(
-          :name => 'foo',
-          :auth_membership => true,
-          :members => []
-        )
-
-        expect(members_property.inclusive?).to be true
-      end
+    it "insync? calls members_insync?" do
+      provider_instance.expects(:members_insync?).with(['user1'], ['user1']).returns true
+      expect(type.property(:members).insync?(['user1'])).to be_truthy
     end
 
-    describe "#should= munging the @should instance variable" do
-      def should_var_of(property)
-        property.instance_variable_get(:@should)
-      end
-
-      it "leaves a single member as-is" do
-        members_property = stub_property(:name => 'foo', :members => [])
-        members_property.should = 'foo'
+    it "is_to_s and should_to_s call members_to_s" do
+      provider_instance.expects(:members_to_s).with(['user1', 'user2']).returns "user1 (), user2 ()"
+      provider_instance.expects(:members_to_s).with(['user1']).returns "user1 ()"
 
-        expect(should_var_of(members_property)).to eql([ 'foo' ])
-      end
-
-      it "leaves an array of members as-is" do
-        members_property = stub_property(:name => 'foo', :members => [])
-        members_property.should = [ 'foo', 'bar' ]
-
-        expect(should_var_of(members_property)).to eql(['foo', 'bar'])
-      end
-
-      it "munges a comma-separated list of members into an array" do
-        members_property = stub_property(:name => 'foo', :members => [])
-        members_property.should = 'foo,bar' 
-
-        expect(should_var_of(members_property)).to eql(['foo', 'bar'])
-      end
+      expect(type.property(:members).is_to_s('user1')).to eq('user1 ()')
+      expect(type.property(:members).should_to_s('user1,user2')).to eq('user1 (), user2 ()')
     end
   end
 end

data/spec/unit/util/log/destinations_spec.rb

@@ -54,6 +54,7 @@ describe Puppet::Util::Log.desttypes[:file] do
         it_behaves_like "file destination"
 
         it "logs an error if it can't chown the file owner & group" do
+          File.expects(:exists?).with(abspath).returns(false)
           FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).raises(Errno::EPERM)
           Puppet.features.expects(:root?).returns(true)
           Puppet.expects(:err).with("Unable to set ownership to #{Puppet[:user]}:#{Puppet[:group]} for log file: #{abspath}")
@@ -62,11 +63,20 @@ describe Puppet::Util::Log.desttypes[:file] do
         end
 
         it "doesn't attempt to chown when running as non-root" do
+          File.expects(:exists?).with(abspath).returns(false)
           FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
           Puppet.features.expects(:root?).returns(false)
 
           @class.new(abspath)
         end
+
+        it "doesn't attempt to chown when file already exists" do
+          File.expects(:exists?).with(abspath).returns(true)
+          FileUtils.expects(:chown).with(Puppet[:user], Puppet[:group], abspath).never
+          Puppet.features.expects(:root?).returns(true)
+
+          @class.new(abspath)
+        end
       end
 
       describe "with a JSON file" do

data/spec/unit/util/suidmanager_spec.rb

@@ -121,9 +121,7 @@ describe Puppet::Util::SUIDManager do
       end
     end
 
-    it "should not get or set euid/egid on Windows" do
-      Puppet.features.stubs(:microsoft_windows?).returns true
-
+    it "should not get or set euid/egid on Windows", if: Puppet::Util::Platform.windows? do
       Puppet::Util::SUIDManager.asuser(user[:uid], user[:gid]) {}
 
       expect(xids).to be_empty

data/spec/unit/util/windows/adsi_spec.rb

@@ -433,7 +433,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
           adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
 
-          group.set_members('user2,DOMAIN2\user3')
+          group.set_members(['user2', 'DOMAIN2\user3'])
         end
 
         it "should add the desired_members to an existing group when not inclusive" do
@@ -460,7 +460,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
 
           adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
 
-          group.set_members('user2,DOMAIN2\user3',false)
+          group.set_members(['user2', 'DOMAIN2\user3'],false)
         end
 
         it "should return immediately when desired_members is nil" do
@@ -492,7 +492,7 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
           adsi_group.expects(:Remove).with('WinNT://testcomputername/user2,user')
 
-          group.set_members('')
+          group.set_members([])
         end
 
         it "should do nothing when desired_members is empty and not inclusive" do
@@ -511,13 +511,13 @@ describe Puppet::Util::Windows::ADSI, :if => Puppet.features.microsoft_windows?
           adsi_group.expects(:Remove).never
           adsi_group.expects(:Add).never
 
-          group.set_members('',false)
+          group.set_members([],false)
         end
 
         it "should raise an error when a username does not resolve to a SID" do
           expect {
             adsi_group.expects(:Members).returns []
-            group.set_members('foobar')
+            group.set_members(['foobar'])
           }.to raise_error(Puppet::Error, /Could not resolve name: foobar/)
         end
       end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: puppet
 version: !ruby/object:Gem::Version
-  version: 5.5.7
+  version: 5.5.8
 platform: x64-mingw32
 authors:
 - Puppet Labs
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-10-22 00:00:00.000000000 Z
+date: 2018-10-31 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: facter
@@ -892,7 +892,6 @@ files:
 - lib/puppet/pops/loader/puppet_resource_type_impl_instantiator.rb
 - lib/puppet/pops/loader/ruby_data_type_instantiator.rb
 - lib/puppet/pops/loader/ruby_function_instantiator.rb
-- lib/puppet/pops/loader/ruby_legacy_function_instantiator.rb
 - lib/puppet/pops/loader/runtime3_type_loader.rb
 - lib/puppet/pops/loader/simple_environment_loader.rb
 - lib/puppet/pops/loader/static_loader.rb

data/lib/puppet/pops/loader/ruby_legacy_function_instantiator.rb

@@ -1,62 +0,0 @@
-# The RubyLegacyFunctionInstantiator instantiates a Puppet::Functions::Function given the ruby source
-# that calls Puppet::Functions.create_function.
-#
-class Puppet::Pops::Loader::RubyLegacyFunctionInstantiator
-  # Produces an instance of the Function class with the given typed_name, or fails with an error if the
-  # given ruby source does not produce this instance when evaluated.
-  #
-  # @param loader [Puppet::Pops::Loader::Loader] The loader the function is associated with
-  # @param typed_name [Puppet::Pops::Loader::TypedName] the type / name of the function to load
-  # @param source_ref [URI, String] a reference to the source / origin of the ruby code to evaluate
-  # @param ruby_code_string [String] ruby code in a string
-  #
-  # @return [Puppet::Pops::Functions.Function] - an instantiated function with global scope closure associated with the given loader
-  #
-  def self.create(loader, typed_name, source_ref, ruby_code_string)
-    unless ruby_code_string.is_a?(String) && ruby_code_string =~ /Puppet\:\:Parser\:\:Functions.*newfunction/m
-      raise ArgumentError, _("The code loaded from %{source_ref} does not seem to be a Puppet 3x API function - no 'newfunction' call.") % { source_ref: source_ref }
-    end
-    # make the private loader available in a binding to allow it to be passed on
-    loader_for_function = loader.private_loader
-    here = get_binding(loader_for_function)
-
-    # Avoid reloading the function if already loaded via one of the APIs that trigger 3x function loading
-    # Check if function is already loaded the 3x way (and obviously not the 4x way since we would not be here in the
-    # first place.
-    environment = Puppet.lookup(:current_environment)
-    func_info = Puppet::Parser::Functions.environment_module(environment).get_function_info(typed_name.name.to_sym)
-    if func_info.nil?
-      # This will to do the 3x loading and define the "function_<name>" and "real_function_<name>" methods
-      # in the anonymous module used to hold function definitions.
-      #
-      func_info = eval(ruby_code_string, here, source_ref, 1)
-
-      # Validate what was loaded
-      unless func_info.is_a?(Hash)
-        raise ArgumentError, _("The code loaded from %{source_ref} did not produce the expected 3x function info Hash when evaluated. Got '%{klass}'") % { source_ref: source_ref, klass: created.class }
-      end
-      unless func_info[:name] == "function_#{typed_name.name()}"
-        raise ArgumentError, _("The code loaded from %{source_ref} produced mis-matched name, expected 'function_%{type_name}', got %{created_name}") % { 
-          source_ref: source_ref, type_name: typed_name.name, created_name: func_info[:name] }
-      end
-    end
-
-    created = Puppet::Functions::Function3x.create_function(typed_name.name(), func_info, loader_for_function)
-
-    # create the function instance - it needs closure (scope), and loader (i.e. where it should start searching for things
-    # when calling functions etc.
-    # It should be bound to global scope
-
-    # Sets closure scope to nil, to let it be picked up at runtime from Puppet.lookup(:global_scope)
-    # If function definition used the loader from the binding to create a new loader, that loader wins
-    created.new(nil, loader_for_function)
-  end
-
-  # Produces a binding where the given loader is bound as a local variable (loader_injected_arg). This variable can be used in loaded
-  # ruby code - e.g. to call Puppet::Function.create_loaded_function(:name, loader,...)
-  #
-  def self.get_binding(loader_injected_arg)
-    binding
-  end
-  private_class_method :get_binding
-end