expand testing

Author: LukasAud

spec/acceptance/deferred_spec.rb

@@ -7,82 +7,69 @@ def read_fixture(name)
   File.read(File.join(__dir__, '..', 'fixtures', 'manifests', name))
 end
 
-# 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}"))
+  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) }
+  { exists: !body.include?('<<<FILE_NOT_FOUND>>>'), content: body.include?('<<<FILE_NOT_FOUND>>>') ? '' : 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_inline)      { read_fixture('02b_dsc_deferred_inline.pp') } # <— NEW
   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 (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_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')
+    out = read_win_file_if_exists('C:/Temp/deferred_ok.txt')
+    expect(out[:exists]).to be(true)
+    expect(out[: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 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)
-
-      r = read_win_file_if_exists('C:/Temp/from_dsc.txt')
-
-      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.
-          Content:
-            #{r[:content].inspect}
-          Puppet apply output:
-            #{apply_output}
-        MSG
-      else
-        # ❌ file missing or unexpected content
-        raise <<~MSG
-          Unexpected outcome for 02_dsc_deferred_direct.
-          File exists? #{r[:exists]}
-          Content (trimmed): #{r[:content].strip.inspect}
-          Puppet apply output:
-            #{apply_output}
-        MSG
-      end
+  it '02: passing Deferred via variable to DSC resolves to hello-dsc (otherwise flag bug)' do
+    apply = apply_manifest(dsc_deferred_direct)
+    out   = read_win_file_if_exists('C:/Temp/from_dsc.txt')
+    content = out[:content].strip
+    if out[:exists] && content == 'hello-dsc'
+      expect(true).to be(true)
+    elsif out[:exists] && content =~ %r{Deferred\s*\(|Puppet::Pops::Types::Deferred}i
+      raise "BUG: 02 wrote stringified Deferred: #{content.inspect}\nApply:\n#{apply.stdout}#{apply.stderr}"
+    else
+      raise "Unexpected 02 outcome. Exists=#{out[:exists]} Content=#{content.inspect}\nApply:\n#{apply.stdout}#{apply.stderr}"
     end
+  end
 
-    it '03a: stringifying a Deferred writes the function form (reproduces customer report)' do
-      apply = apply_manifest(dsc_deferred_stringified)
-      expect(apply.exit_code).to eq(2).or eq(0) # change or noop is fine
-
-      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})
+  # NEW 02b: inline Deferred on the DSC property (no variable intermediary)
+  it '02b: passing Deferred inline to DSC resolves to hello-dsc-inline (otherwise flag bug)' do
+    apply = apply_manifest(dsc_deferred_inline)
+    out   = read_win_file_if_exists('C:/Temp/from_dsc_inline.txt')
+    content = out[:content].strip
+    if out[:exists] && content == 'hello-dsc-inline'
+      expect(true).to be(true)
+    elsif out[:exists] && content =~ %r{Deferred\s*\(|Puppet::Pops::Types::Deferred}i
+      raise "BUG: 02b wrote stringified Deferred: #{content.inspect}\nApply:\n#{apply.stdout}#{apply.stderr}"
+    else
+      raise "Unexpected 02b outcome. Exists=#{out[:exists]} Content=#{content.inspect}\nApply:\n#{apply.stdout}#{apply.stderr}"
     end
+  end
 
-    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)
+  it '03a: stringifying a Deferred writes the function form (reproduces customer report)' do
+    apply = apply_manifest(dsc_deferred_stringified)
+    out   = read_win_file_if_exists('C:/Temp/from_dsc_var_string.txt')
+    expect(out[:exists]).to be(true)
+    expect(out[:content]).to match(%r{Deferred\s*\(|Puppet::Pops::Types::Deferred}i)
+    expect(out[:content]).not_to match(%r{\bhello-var\b})
+  end
 
-      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
+  it '03b: unwrap on a non‑Sensitive is a no‑op; also writes the function form' do
+    apply = apply_manifest(dsc_deferred_bad_unwrap)
+    out   = read_win_file_if_exists('C:/Temp/from_dsc_var_bad_unwrap.txt')
+    out   = read_win_file_if_exists('C:/Temp/from_dsc_var.txt') unless out[:exists]
+    expect(out[:exists]).to be(true)
+    expect(out[:content]).to match(%r{Deferred\s*\(|Puppet::Pops::Types::Deferred}i)
+    expect(out[:content]).not_to match(%r{\bhello-var\b})
   end
 end

spec/fixtures/manifests/02b_dsc_deferred_inline.pp

@@ -0,0 +1,16 @@
+# spec/fixtures/manifests/02b_dsc_deferred_inline.pp
+file { 'C:/Temp':
+  ensure => directory,
+}
+
+dsc { 'WriteFileViaDSCInline':
+  resource_name => 'File',
+  module        => 'PSDesiredStateConfiguration',
+  properties    => {
+    'DestinationPath' => 'C:\Temp\from_dsc_inline.txt',
+    'Type'            => 'File',
+    'Ensure'          => 'Present',
+    'Contents'        => Deferred('join', [['hello','-','dsc-inline'], '']),
+  },
+  require => File['C:/Temp'],
+}