ruby-pwsh 1.0.1 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dd8ad4546d9fbdc7bf62c17f8132adb9647e311e9e3319b22b5161f924fd94c3
-  data.tar.gz: c607771ae691c4593b839cc1134d3e0fcc15b0a454eef93a3b146301d13b3411
+  metadata.gz: 1ac282abeea132104fda1b3fc2f4743f4b99603cdd6b73a42b7063641c9e65d9
+  data.tar.gz: 410bc1d7a7b08366a89019324b172219102197f8aa6891bcfaa1729e3bd76925
 SHA512:
-  metadata.gz: e8efb9f23a1fe2302369938416d08e463c4c5e088712dac293b10f0e8abc09431f91057039f95f918382e4775b932da4ab270901591f58d834a01c1d784d4fe6
-  data.tar.gz: 788c3c601d46c37478b41abe5a068eac7da7c0912ec71f703841f4d462a3363d2c613bbeb8356b6a38b21a3870eec0d567e4bfa2d2892a40aadd1e4a62dc38e1
+  metadata.gz: 0fd8c7af3f87ce61121a7404b66cfae5cf78fea8bdb885dc7715467bb5092bd974a9fd4d7f94824fe10675d56b4e4dc7b439826f95bc5d9672f14fcb74692501
+  data.tar.gz: 198328e45920aa2794cab2984e090c14c81ce56b4b038e4ae0b7f22ad66d327d0bbd34b5726709108c14609324dba1687a83a2f67026a2d8abf12d749067ca27

data/.rubocop.yml

@@ -18,6 +18,9 @@ AllCops:
 Style/ClassAndModuleChildren:
   Enabled: false
 
+Layout/LineLength:
+  Max: 196
+
 ####################################################
 # Cops below here due for deprecation
 ####################################################

data/lib/puppet/provider/dsc_base_provider/dsc_base_provider.rb

@@ -5,7 +5,7 @@ require 'ruby-pwsh'
 require 'pathname'
 require 'json'
 
-class Puppet::Provider::DscBaseProvider
+class Puppet::Provider::DscBaseProvider # rubocop:disable Metrics/ClassLength
   # Initializes the provider, preparing the instance variables which cache:
   # - the canonicalized resources across calls
   # - query results
@@ -44,6 +44,7 @@ class Puppet::Provider::DscBaseProvider
   # @param context [Object] the Puppet runtime context to operate in and send feedback to
   # @param resources [Hash] the hash of the resource to canonicalize from either manifest or invocation
   # @return [Hash] returns a hash representing the current state of the object, if it exists
+  # rubocop:disable Metrics/BlockLength, Metrics/MethodLength
   def canonicalize(context, resources)
     canonicalized_resources = []
     resources.collect do |r|
@@ -83,9 +84,18 @@ class Puppet::Provider::DscBaseProvider
             downcased_result.each do |key, value|
               # Canonicalize to the manifest value unless the downcased strings match and the attribute is not an enum:
               # - When the values don't match at all, the manifest value is desired;
-              # - When the values match case insensitively but the attribute is an enum, prefer the casing of the manifest enum.
-              # - When the values match case insensitively and the attribute is not an enum, prefer the casing from invoke_get_method
-              canonicalized[key] = r[key] unless same?(value, downcased_resource[key]) && !enum_attributes(context).include?(key)
+              # - When the values match case insensitively but the attribute is an enum, and the casing from invoke_get_method
+              #   is not int the enum, prefer the casing of the manifest enum.
+              # - When the values match case insensitively and the attribute is not an enum, or is an enum and invoke_get_method casing
+              #   is in the enum, prefer the casing from invoke_get_method
+              is_enum = enum_attributes(context).include?(key)
+              canonicalized_value_in_enum = if is_enum
+                                              enum_values(context, key).include?(canonicalized[key])
+                                            else
+                                              false
+                                            end
+              match_insensitively = same?(value, downcased_resource[key])
+              canonicalized[key] = r[key] unless match_insensitively && (canonicalized_value_in_enum || !is_enum)
               canonicalized.delete(key) unless downcased_resource.key?(key)
             end
             # Cache the actually canonicalized resource separately
@@ -104,6 +114,7 @@ class Puppet::Provider::DscBaseProvider
     context.debug("Canonicalized Resources: #{canonicalized_resources}")
     canonicalized_resources
   end
+  # rubocop:enable Metrics/BlockLength, Metrics/MethodLength
 
   # Attempts to retrieve an instance of the DSC resource, invoking the `Get` method and passing any
   # namevars as the Properties to Invoke-DscResource. The result object, if any, is compared to the
@@ -244,6 +255,7 @@ class Puppet::Provider::DscBaseProvider
     script_content = ps_script_content(resource)
     context.debug("Script:\n #{redact_secrets(script_content)}")
     output = ps_manager.execute(remove_secret_identifiers(script_content))[:stdout]
+
     if output.nil?
       context.err('Nothing returned')
       return nil
@@ -256,8 +268,10 @@ class Puppet::Provider::DscBaseProvider
       return nil
     end
     context.debug("raw data received: #{data.inspect}")
+    collision_error_matcher = /The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked/
 
     error = data['errormessage']
+
     unless error.nil? || error.empty?
       # NB: We should have a way to stop processing this resource *now* without blowing up the whole Puppet run
       # Raising an error stops processing but blows things up while context.err alerts but continues to process
@@ -267,6 +281,11 @@ class Puppet::Provider::DscBaseProvider
         @logon_failures << name_hash[:dsc_psdscrunascredential].dup
         # This is a hack to handle the query cache to prevent a second lookup
         @cached_query_results << name_hash # if fetch_cached_hashes(@cached_query_results, [data]).empty?
+      elsif error.match?(collision_error_matcher)
+        context.notice('Invoke-DscResource collision detected: Please stagger the timing of your Puppet runs as this can lead to unexpected behaviour.')
+        retry_invoke_dsc_resource(context, 5, 60, collision_error_matcher) do
+          data = ps_manager.execute(remove_secret_identifiers(script_content))[:stdout]
+        end
       else
         context.err(error)
       end
@@ -276,6 +295,35 @@ class Puppet::Provider::DscBaseProvider
     data
   end
 
+  # Retries Invoke-DscResource when returned error matches error regex supplied as param.
+  # @param context [Object] the Puppet runtime context to operate in and send feedback to
+  # @param max_retry_count [Int] max number of times to retry Invoke-DscResource
+  # @param retry_wait_interval_secs [Int] Time delay between retries
+  # @param error_matcher [String] the regex pattern to match with error
+  def retry_invoke_dsc_resource(context, max_retry_count, retry_wait_interval_secs, error_matcher)
+    try = 0
+    while try < max_retry_count
+      try += 1
+      # notify and wait for retry interval
+      context.notice("Sleeping for #{retry_wait_interval_secs} seconds.")
+      sleep retry_wait_interval_secs
+      # notify and retry
+      context.notice("Retrying: attempt #{try} of #{max_retry_count}.")
+      data = JSON.parse(yield)
+      # if no error, assume successful invocation and break
+      break if data['errormessage'].nil?
+
+      # notify of failed retry
+      context.notice("Attempt #{try} of #{max_retry_count} failed.")
+      # return if error does not match expceted error, or all retries exhausted
+      return context.err(data['errormessage']) unless data['errormessage'].match?(error_matcher) && try < max_retry_count
+
+      # else, retry
+      next
+    end
+    data
+  end
+
   # Determine if the DSC Resource is in the desired state, invoking the `Test` method unless it's
   #   already been run for the resource, in which case reuse the result instead of checking for each
   #   property. This behavior is only triggered if the validation_mode is set to resource; by default
@@ -303,7 +351,7 @@ class Puppet::Provider::DscBaseProvider
   # @param context [Object] the Puppet runtime context to operate in and send feedback to
   # @param name_hash [Hash] the hash of namevars to be passed as properties to `Invoke-DscResource`
   # @return [Hash] returns a hash representing the DSC resource munged to the representation the Puppet Type expects
-  def invoke_get_method(context, name_hash)
+  def invoke_get_method(context, name_hash) # rubocop:disable Metrics/AbcSize
     context.debug("retrieving #{name_hash.inspect}")
 
     query_props = name_hash.select { |k, v| mandatory_get_attributes(context).include?(k) || (k == :dsc_psdscrunascredential && !v.nil?) }
@@ -346,6 +394,8 @@ class Puppet::Provider::DscBaseProvider
     # If a resource is found, it's present, so refill this Puppet-only key
     data[:name] = name_hash[:name]
 
+    data = stringify_nil_attributes(context, data)
+
     # Have to check for this to avoid a weird canonicalization warning
     # The Resource API calls canonicalize against the current state which
     # will lead to dsc_ensure being set to absent in the name_hash even if
@@ -615,6 +665,20 @@ class Puppet::Provider::DscBaseProvider
     context.type.attributes.select { |_attribute, properties| properties[:mandatory_for_set] }.keys
   end
 
+  # Parses the DSC resource type definition to retrieve the names of any attributes which are specifed as required strings
+  # This is used to ensure that any nil values are converted to empty strings to match puppets expecetd value
+  # @param context [Object] the Puppet runtime context to operate in and send feedback to
+  # @param data [Hash] the hash of properties returned from the DSC resource
+  # @return [Hash] returns a data hash with any nil values converted to empty strings
+  def stringify_nil_attributes(context, data)
+    nil_strings = data.select { |_name, value| value.nil? }.keys
+    string_attrs = context.type.attributes.select { |_name, properties| properties[:type] == 'String' }.keys
+    string_attrs.each do |attribute|
+      data[attribute] = '' if nil_strings.include?(attribute)
+    end
+    data
+  end
+
   # Parses the DSC resource type definition to retrieve the names of any attributes which are specified as namevars
   #
   # @param context [Object] the Puppet runtime context to operate in and send feedback to
@@ -641,6 +705,28 @@ class Puppet::Provider::DscBaseProvider
     context.type.attributes.select { |_name, properties| properties[:type].include?('Enum[') }.keys
   end
 
+  # Parses the DSC resource type definition to retrieve the values of any attributes which are specified as enums
+  #
+  # @param context [Object] the Puppet runtime context to operate in and send feedback to
+  # @param attribute [String] the enum attribute to retrieve the allowed values from
+  # @return [Array] returns an array of attribute names as symbols which are enums
+  def enum_values(context, attribute)
+    # Get the attribute's type string for the given key
+    type_string = context.type.attributes[attribute][:type]
+
+    # Return an empty array if the key doesn't have an Enum type or doesn't exist
+    return [] unless type_string&.include?('Enum[')
+
+    # Extract the enum values from the type string
+    enum_content = type_string.match(/Enum\[(.*?)\]/)&.[](1)
+
+    # Return an empty array if we couldn't find the enum values
+    return [] if enum_content.nil?
+
+    # Return an array of the enum values, stripped of extra whitespace and quote marks
+    enum_content.split(',').map { |val| val.strip.delete('\'') }
+  end
+
   # Look through a fully formatted string, replacing all instances where a value matches the formatted properties
   # of an instantiated variable with references to the variable instead. This allows us to pass complex and nested
   # CIM instances to the Invoke-DscResource parameter hash without constructing them *in* the hash.
@@ -666,7 +752,7 @@ class Puppet::Provider::DscBaseProvider
   # @param resource [Hash] a hash with the information needed to run `Invoke-DscResource`
   # @return [String] A multi-line string which sets the PSModulePath at the system level
   def munge_psmodulepath(resource)
-    vendor_path = resource[:vendored_modules_path].tr('/', '\\')
+    vendor_path = resource[:vendored_modules_path]&.tr('/', '\\')
     <<~MUNGE_PSMODULEPATH.strip
       $UnmungedPSModulePath = [System.Environment]::GetEnvironmentVariable('PSModulePath','machine')
       $MungedPSModulePath = $env:PSModulePath + ';#{vendor_path}'

data/lib/pwsh/version.rb

@@ -2,5 +2,5 @@
 
 module Pwsh
   # The version of the ruby-pwsh gem
-  VERSION = '1.0.1'
+  VERSION = '1.1.1'
 end

data/spec/spec_helper.rb

@@ -1,5 +1,30 @@
 # frozen_string_literal: true
 
+if ENV['COVERAGE'] == 'yes'
+  begin
+    require 'simplecov'
+    require 'simplecov-console'
+
+    SimpleCov.formatters = [
+      SimpleCov::Formatter::HTMLFormatter,
+      SimpleCov::Formatter::Console
+    ]
+
+    SimpleCov.start do
+      track_files 'lib/**/*.rb'
+
+      add_filter '/spec'
+      add_filter 'lib/pwsh/version.rb'
+
+      # do not track vendored files
+      add_filter '/vendor'
+      add_filter '/.vendor'
+    end
+  rescue LoadError
+    raise 'Add the simplecov & simplecov-console gems to Gemfile to enable this task'
+  end
+end
+
 require 'bundler/setup'
 require 'ruby-pwsh'
 

data/spec/unit/puppet/provider/dsc_base_provider/dsc_base_provider_spec.rb

@@ -2,23 +2,24 @@
 
 require 'spec_helper'
 require 'puppet/type'
+require 'puppet/resource_api'
 require 'puppet/provider/dsc_base_provider/dsc_base_provider'
 require 'json'
 
 RSpec.describe Puppet::Provider::DscBaseProvider do
   subject(:provider) { described_class.new }
 
-  let(:context) { instance_double(Puppet::ResourceApi::PuppetContext) }
-  let(:type) { instance_double(Puppet::ResourceApi::TypeDefinition) }
+  let(:context) { instance_double(Puppet::ResourceApi::BaseContext, 'context') }
+  let(:type) { instance_double(Puppet::ResourceApi::TypeDefinition, 'typedef') }
   let(:ps_manager) { instance_double(Pwsh::Manager) }
   let(:execute_response) { { stdout: nil, stderr: nil, exitcode: 0 } }
 
   # Reset the caches after each run
   after do
-    described_class.instance_variable_set(:@cached_canonicalized_resource, [])
-    described_class.instance_variable_set(:@cached_query_results, [])
-    described_class.instance_variable_set(:@cached_test_results, [])
-    described_class.instance_variable_set(:@logon_failures, [])
+    provider.instance_variable_set(:@cached_canonicalized_resource, [])
+    provider.instance_variable_set(:@cached_query_results, [])
+    provider.instance_variable_set(:@cached_test_results, [])
+    provider.instance_variable_set(:@logon_failures, [])
   end
 
   describe '.initialize' do
@@ -28,27 +29,30 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     it 'initializes the cached_canonicalized_resource instance variable' do
-      expect(described_class.instance_variable_get(:@cached_canonicalized_resource)).to eq([])
+      expect(provider.instance_variable_get(:@cached_canonicalized_resource)).to eq([])
     end
 
     it 'initializes the cached_query_results instance variable' do
-      expect(described_class.instance_variable_get(:@cached_query_results)).to eq([])
+      expect(provider.instance_variable_get(:@cached_query_results)).to eq([])
     end
 
     it 'initializes the cached_test_results instance variable' do
-      expect(described_class.instance_variable_get(:@cached_test_results)).to eq([])
+      expect(provider.instance_variable_get(:@cached_test_results)).to eq([])
     end
 
     it 'initializes the logon_failures instance variable' do
-      expect(described_class.instance_variable_get(:@logon_failures)).to eq([])
+      expect(provider.instance_variable_get(:@logon_failures)).to eq([])
     end
   end
 
   describe '.cached_test_results' do
     let(:cache_value) { %w[foo bar] }
 
+    before do
+      provider.instance_variable_set(:@cached_test_results, cache_value)
+    end
+
     it 'returns the value of the @cached_test_results instance variable' do
-      described_class.instance_variable_set(:@cached_test_results, cache_value)
       expect(provider.cached_test_results).to eq(cache_value)
     end
   end
@@ -175,6 +179,8 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
             end
 
             it 'treats the manifest value as canonical' do
+              expect(context).to receive(:type).and_return(type)
+              expect(type).to receive(:attributes).and_return({ dsc_property: { type: "Enum['Dword']" } })
               expect(canonicalized_resource.first[:dsc_property]).to eq('Dword')
             end
           end
@@ -237,11 +243,11 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
   describe '.get' do
     after do
-      described_class.instance_variable_set(:@cached_canonicalized_resource, [])
+      provider.instance_variable_set(:@cached_canonicalized_resource, [])
     end
 
     it 'checks the cached results, returning if one exists for the specified names' do
-      described_class.instance_variable_set(:@cached_canonicalized_resource, [])
+      provider.instance_variable_set(:@cached_canonicalized_resource, [])
       allow(context).to receive(:debug)
       expect(provider).to receive(:fetch_cached_hashes).with([], [{ name: 'foo' }]).and_return([{ name: 'foo', property: 'bar' }])
       expect(provider).not_to receive(:invoke_get_method)
@@ -249,7 +255,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     it 'adds mandatory properties to the name hash when calling invoke_get_method' do
-      described_class.instance_variable_set(:@cached_canonicalized_resource, [{ name: 'foo', property: 'bar', dsc_some_parameter: 'baz' }])
+      provider.instance_variable_set(:@cached_canonicalized_resource, [{ name: 'foo', property: 'bar', dsc_some_parameter: 'baz' }])
       allow(context).to receive(:debug)
       expect(provider).to receive(:fetch_cached_hashes).with([], [{ name: 'foo' }]).and_return([])
       expect(provider).to receive(:namevar_attributes).and_return([:name]).exactly(3).times
@@ -530,7 +536,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     after do
-      described_class.instance_variable_set(:@cached_query_results, nil)
+      provider.instance_variable_set(:@cached_query_results, [])
     end
 
     context 'when the invocation script returns data without errors' do
@@ -557,7 +563,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
       it 'caches the result' do
         expect { result }.not_to raise_error
-        expect(described_class.instance_variable_get(:@cached_query_results)).to eq([result])
+        expect(provider.instance_variable_get(:@cached_query_results)).to eq([result])
       end
 
       it 'removes unrelated properties from the result' do
@@ -719,7 +725,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
         end
 
         after do
-          described_class.instance_variable_set(:@logon_failures, [])
+          provider.instance_variable_set(:@logon_failures, [])
         end
 
         it 'errors specifically for a logon failure and returns nil' do
@@ -728,12 +734,12 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
         it 'caches the logon failure' do
           expect { result }.not_to raise_error
-          expect(described_class.instance_variable_get(:@logon_failures)).to eq([credential_hash])
+          expect(provider.instance_variable_get(:@logon_failures)).to eq([credential_hash])
         end
 
         it 'caches the query results' do
           expect { result }.not_to raise_error
-          expect(described_class.instance_variable_get(:@cached_query_results)).to eq([name_hash])
+          expect(provider.instance_variable_get(:@cached_query_results)).to eq([name_hash])
         end
       end
 
@@ -790,6 +796,45 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
       end
     end
 
+    context 'when the invocation script errors with a collision' do
+      it 'writes a notice via context and applies successfully on retry' do
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked"}' })
+        expect(context).to receive(:notice).with(/Invoke-DscResource collision detected: Please stagger the timing of your Puppet runs as this can lead to unexpected behaviour./).once
+        expect(context).to receive(:notice).with('Sleeping for 60 seconds.').twice
+        expect(context).to receive(:notice).with(/Retrying: attempt [1-2] of 5/).twice
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked"}' })
+        expect(context).to receive(:notice).with('Attempt 1 of 5 failed.')
+        allow(provider).to receive(:sleep)
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": null}' })
+        expect { result }.not_to raise_error
+      end
+
+      it 'writes a error via context and fails to apply when all retry attempts used' do
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked"}' })
+                                               .exactly(5).times
+        expect(context).to receive(:notice).with(/Invoke-DscResource collision detected: Please stagger the timing of your Puppet runs as this can lead to unexpected behaviour./).once
+        expect(context).to receive(:notice).with('Sleeping for 60 seconds.').exactly(5).times
+        expect(context).to receive(:notice).with(/Retrying: attempt [1-5] of 5/).exactly(5).times
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked"}' })
+        expect(context).to receive(:notice).with(/Attempt [1-5] of 5 failed/).exactly(5).times
+        expect(context).to receive(:err).with(/The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked/)
+        allow(provider).to receive(:sleep)
+        expect(result).to be_nil
+      end
+
+      it 'writes an error via context and fails to apply when encountering an unexpected error' do
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "The Invoke-DscResource cmdlet is in progress and must return before Invoke-DscResource can be invoked"}' })
+        expect(context).to receive(:notice).with(/Invoke-DscResource collision detected: Please stagger the timing of your Puppet runs as this can lead to unexpected behaviour./).once
+        expect(context).to receive(:notice).with('Sleeping for 60 seconds.').once
+        expect(context).to receive(:notice).with(/Retrying: attempt 1 of 5/).once
+        allow(provider).to receive(:sleep)
+        expect(ps_manager).to receive(:execute).and_return({ stdout: '{"errormessage": "Some unexpected error"}' }).once
+        expect(context).to receive(:notice).with(/Attempt 1 of 5 failed/).once
+        expect(context).to receive(:err).with(/Some unexpected error/)
+        expect(result).to be_nil
+      end
+    end
+
     context 'when the invocation script returns data without errors' do
       it 'filters for the correct properties to invoke and returns the results' do
         expect(ps_manager).to receive(:execute).with("Script: #{apply_props}").and_return({ stdout: '{"in_desired_state": true, "errormessage": null}' })
@@ -981,11 +1026,11 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
   end
 
   describe '.invoke_test_method' do
-    subject(:result) { provider.invoke_test_method(context, name, expect(subject).to) }
+    subject(:result) { provider.invoke_test_method(context, name, should_hash) }
 
     let(:name) { { name: 'foo', dsc_name: 'bar' } }
-    let(:should) { name.merge(dsc_ensure: 'present') }
-    let(:test_properties) { expect(subject).to.reject { |k, _v| k == :name } }
+    let(:should_hash) { name.merge(dsc_ensure: 'present') }
+    let(:test_properties) { should_hash.reject { |k, _v| k == :name } }
     let(:invoke_dsc_resource_data) { nil }
 
     before do
@@ -995,7 +1040,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     after do
-      described_class.instance_variable_set(:@cached_test_results, [])
+      provider.instance_variable_set(:@cached_test_results, [])
     end
 
     context 'when something went wrong calling Invoke-DscResource' do
@@ -1043,7 +1088,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
   describe '.instantiated_variables' do
     after do
-      described_class.instance_variable_set(:@instantiated_variables, [])
+      provider.instance_variable_set(:@instantiated_variables, [])
     end
 
     it 'sets the instantiated_variables instance variable to {} if not initialized' do
@@ -1051,20 +1096,20 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     it 'returns the instantiated_variables instance variable if already initialized' do
-      described_class.instance_variable_set(:@instantiated_variables, { foo: 'bar' })
+      provider.instance_variable_set(:@instantiated_variables, { foo: 'bar' })
       expect(provider.instantiated_variables).to eq({ foo: 'bar' })
     end
   end
 
   describe '.clear_instantiated_variables!' do
     after do
-      described_class.instance_variable_set(:@instantiated_variables, [])
+      provider.instance_variable_set(:@instantiated_variables, [])
     end
 
     it 'sets the instantiated_variables instance variable to {}' do
-      described_class.instance_variable_set(:@instantiated_variables, { foo: 'bar' })
+      provider.instance_variable_set(:@instantiated_variables, { foo: 'bar' })
       expect { provider.clear_instantiated_variables! }.not_to raise_error
-      expect(described_class.instance_variable_get(:@instantiated_variables)).to eq({})
+      expect(provider.instance_variable_get(:@instantiated_variables)).to eq({})
     end
   end
 
@@ -1087,16 +1132,16 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
       end
 
       after do
-        described_class.instance_variable_set(:@logon_failures, [])
+        provider.instance_variable_set(:@logon_failures, [])
       end
 
       it 'returns false if there have been no failed logons with the username/password combination' do
-        described_class.instance_variable_set(:@logon_failures, [bad_credential_hash])
+        provider.instance_variable_set(:@logon_failures, [bad_credential_hash])
         expect(provider.logon_failed_already?(good_credential_hash)).to be(false)
       end
 
       it 'returns true if the username/password specified are found in the logon_failures instance variable' do
-        described_class.instance_variable_set(:@logon_failures, [good_credential_hash, bad_credential_hash])
+        provider.instance_variable_set(:@logon_failures, [good_credential_hash, bad_credential_hash])
         expect(provider.logon_failed_already?(bad_credential_hash)).to be(true)
       end
     end
@@ -1437,16 +1482,18 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     context 'when the resource does not have the dscmeta_resource_implementation key' do
       let(:test_resource) { {} }
 
-      it 'returns nil' do
-        expect(result).to be_nil
+      it 'sets $UnmungedPSModulePath to the current PSModulePath' do
+        # since https://github.com/puppetlabs/ruby-pwsh/pull/261 we load vendored path for MOF resources as well
+        expect(result).to match(/\$UnmungedPSModulePath = .+GetEnvironmentVariable.+PSModulePath.+machine/)
       end
     end
 
     context "when the resource's dscmeta_resource_implementation is not 'Class'" do
       let(:test_resource) { { dscmeta_resource_implementation: 'MOF' } }
 
-      it 'returns nil' do
-        expect(result).to be_nil
+      # since https://github.com/puppetlabs/ruby-pwsh/pull/261 we load vendored path for MOF resources as well
+      it 'sets $UnmungedPSModulePath to the current PSModulePath' do
+        expect(result).to match(/\$UnmungedPSModulePath = .+GetEnvironmentVariable.+PSModulePath.+machine/)
       end
     end
 
@@ -1510,7 +1557,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
       end
 
       after do
-        described_class.instance_variable_set(:@instantiated_variables, [])
+        provider.instance_variable_set(:@instantiated_variables, [])
       end
 
       it 'writes the ruby representation of the credentials as the value of a key named for the new variable into the instantiated_variables cache' do
@@ -1543,7 +1590,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     subject(:result) { provider.prepare_cim_instances(test_resource) }
 
     after do
-      described_class.instance_variable_set(:@instantiated_variables, [])
+      provider.instance_variable_set(:@instantiated_variables, [])
     end
 
     context 'when a cim instance is passed without nested cim instances' do
@@ -1652,7 +1699,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
 
   describe '.format_ciminstance' do
     after do
-      described_class.instance_variable_set(:@instantiated_variables, [])
+      provider.instance_variable_set(:@instantiated_variables, [])
     end
 
     it 'defines and returns a new cim instance as a PowerShell variable, passing the class name and property hash' do
@@ -1668,7 +1715,7 @@ RSpec.describe Puppet::Provider::DscBaseProvider do
     end
 
     it 'interpolates variables in the case of a cim instance containing a nested instance' do
-      described_class.instance_variable_set(:@instantiated_variables, { 'SomeVariable' => { 'bar' => 'ope' } })
+      provider.instance_variable_set(:@instantiated_variables, { 'SomeVariable' => { 'bar' => 'ope' } })
       property_hash = { 'foo' => { 'bar' => 'ope' } }
       expect(provider.format_ciminstance('foo', 'SomeClass', property_hash)).to match(/@\{'foo' = \$SomeVariable\}/)
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-pwsh
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.1
 platform: ruby
 authors:
 - Puppet, Inc.
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-12-13 00:00:00.000000000 Z
+date: 2024-02-21 00:00:00.000000000 Z
 dependencies: []
 description: PowerShell code manager for ruby.
 email: