adjustment

Author: LukasAud

spec/acceptance/deferred_spec.rb

@@ -7,80 +7,82 @@ def read_fixture(name)
   File.read(File.join(__dir__, '..', 'fixtures', 'manifests', name))
 end
 
-def read_win_file(path)
-  run_shell(%(powershell.exe -NoProfile -NonInteractive -Command "(Get-Content -Raw '#{path}')" ))
+# Returns a struct-like Hash: { exists: true|false, content: String }
+def read_win_file_if_exists(path)
+  # Always exit 0; emit a marker if the file is missing
+  ps = %{$p='#{path}'; if (Test-Path -LiteralPath $p) { Get-Content -Raw -LiteralPath $p } else { '<<<FILE_NOT_FOUND>>>' }}
+  r = run_shell(%(powershell.exe -NoProfile -NonInteractive -Command "#{ps}"))
+  body = (r.stdout || '').to_s
+  missing = body.include?('<<<FILE_NOT_FOUND>>>')
+  { exists: !missing, content: (missing ? '' : body) }
 end
 
 describe 'deferred values with dsc_lite' do
-  let(:control_manifest)            { read_fixture('01_file_deferred.pp') }
-  let(:dsc_deferred_direct)         { read_fixture('02_dsc_deferred_direct.pp') }
-  let(:dsc_deferred_stringified)    { read_fixture('03a_dsc_deferred_stringified.pp') }
-  let(:dsc_deferred_bad_unwrap)     { read_fixture('03b_dsc_deferred_bad_unwrap.pp') }
+  let(:control_manifest)         { read_fixture('01_file_deferred.pp') }
+  let(:dsc_deferred_direct)      { read_fixture('02_dsc_deferred_direct.pp') }
+  let(:dsc_deferred_stringified) { read_fixture('03a_dsc_deferred_stringified.pp') }
+  let(:dsc_deferred_bad_unwrap)  { read_fixture('03b_dsc_deferred_bad_unwrap.pp') }
 
-  it 'control: native file + Deferred resolves to hello-file' do
+  it 'control (01): native file + Deferred resolves to hello-file' do
     result = idempotent_apply(control_manifest)
     expect(result.exit_code).to eq(0)
 
-    r = read_win_file('C:/Temp/deferred_ok.txt')
-    expect(r.exit_code).to eq(0)
-    # Your 01 manifest writes "hello-file"
-    expect(r.stdout.strip).to eq('hello-file')
+    r = read_win_file_if_exists('C:/Temp/deferred_ok.txt')
+    expect(r[:exists]).to be(true), 'C:/Temp/deferred_ok.txt was not created'
+    expect(r[:content].strip).to eq('hello-file')
   end
 
   context 'dsc_lite with Deferred' do
-    it '02: passing Deferred directly to DSC resolves to hello-dsc (otherwise flag the bug)' do
-      result = apply_manifest(dsc_deferred_direct) # no expect_failures
+    it '02: passing Deferred directly to DSC resolves to hello-dsc (otherwise flag bug with diagnostics)' do
+      apply = apply_manifest(dsc_deferred_direct) # not expecting failures by default
+      apply_output = (apply.stdout.to_s + apply.stderr.to_s)
 
-      # We still verify end state regardless of exit code, but this helps failure messaging
-      apply_output = (result.stdout.to_s + result.stderr.to_s)
+      r = read_win_file_if_exists('C:/Temp/from_dsc.txt')
 
-      r = read_win_file('C:/Temp/from_dsc.txt')
-      content = r.stdout.to_s.strip
-
-      if r.exit_code.zero? && content == 'hello-dsc'
-        # ✅ Success: DSC got the resolved value from the agent
-        expect(content).to eq('hello-dsc')
-      elsif r.exit_code.zero? && content =~ %r{Deferred\s*\(|Puppet::Pops::Types::Deferred}i
-        # ❌ Bug reproduced: provider/stringification allowed the wrapper through
+      if r[:exists] && r[:content].strip == 'hello-dsc'
+        # ✅ good case
+        expect(true).to be(true)
+      elsif r[:exists] && r[:content] =~ %r{Deferred\s*\(|Puppet::Pops::Types::Deferred}i
+        # ❌ bug: stringified wrapper made it through to DSC
         raise <<~MSG
           BUG: DSC wrote a stringified Deferred instead of the resolved value.
-          Got content:
-            #{content.inspect}
-          Apply output:
+          Content:
+            #{r[:content].inspect}
+          Puppet apply output:
             #{apply_output}
         MSG
       else
-        # ❌ Some other failure/unexpected content
+        # ❌ file missing or unexpected content
         raise <<~MSG
           Unexpected outcome for 02_dsc_deferred_direct.
-          Exit: #{result.exit_code}
-          File content: #{content.inspect}
-          Apply output:
+          File exists? #{r[:exists]}
+          Content (trimmed): #{r[:content].strip.inspect}
+          Puppet apply output:
             #{apply_output}
         MSG
       end
     end
 
     it '03a: stringifying a Deferred writes the function form (reproduces customer report)' do
-      result = apply_manifest(dsc_deferred_stringified) # no expect_failures
-      expect(result.exit_code).to eq(0)
-
-      r = read_win_file('C:/Temp/from_dsc_var_string.txt')
-      expect(r.exit_code).to eq(0)
+      apply = apply_manifest(dsc_deferred_stringified)
+      expect(apply.exit_code).to eq(2).or eq(0) # change or noop is fine
 
-      body = r.stdout.to_s
-      # Should look like a stringified wrapper, NOT the resolved "hello-var"
-      expect(body).to match(%r{Deferred\s*\(|Puppet::Pops::Types::Deferred}i)
-      expect(body).not_to match(%r{\bhello-var\b})
+      r = read_win_file_if_exists('C:/Temp/from_dsc_var_string.txt')
+      expect(r[:exists]).to be(true), 'C:/Temp/from_dsc_var_string.txt was not created'
+      expect(r[:content]).to match(%r{Deferred\s*\(|Puppet::Pops::Types::Deferred}i)
+      expect(r[:content]).not_to match(%r{\bhello-var\b})
     end
 
-    it '03b: bad unwrap on a Deferred fails to compile with an unwrap/dispatch error' do
-      # This scenario is expected to fail at compile time because unwrap applies to Sensitive, not Deferred.
-      result = apply_manifest(dsc_deferred_bad_unwrap, expect_failures: true)
-      combined = (result.stdout.to_s + result.stderr.to_s)
+    it '03b: bad unwrap on a Deferred does NOT fail compilation; it also writes the function form' do
+      # unwrap on non-Sensitive returns the argument unchanged, so this will NOT fail compilation.
+      # It will stringify the Deferred and write that text via DSC (same symptom as 03a).  [1](https://docs.huihoo.com/puppet/puppet/2.7/reference/lang_resources.html)
+      apply = apply_manifest(dsc_deferred_bad_unwrap)
+      expect(apply.exit_code).to eq(2).or eq(0)
 
-      # Be generous on the match to cover different Puppet versions/wordings
-      expect(combined).to match(%r{unwrap|NoMethodError|dispatch|undefined method}i)
+      r = read_win_file_if_exists('C:/Temp/from_dsc_var_bad_unwrap.txt')
+      expect(r[:exists]).to be(true), 'C:/Temp/from_dsc_var_bad_unwrap.txt was not created'
+      expect(r[:content]).to match(%r{Deferred\s*\(|Puppet::Pops::Types::Deferred}i)
+      expect(r[:content]).not_to match(%r{\bhello-var\b})
     end
   end
 end