puppet 4.0.0 → 4.9.1

data/spec/{unit → integration}/util/windows/registry_spec.rb

@@ -2,10 +2,30 @@
 require 'spec_helper'
 require 'puppet/util/windows'
 
-describe Puppet::Util::Windows::Registry, :if => Puppet::Util::Platform.windows? do
+if Puppet::Util::Platform.windows?
+describe Puppet::Util::Windows::Registry do
   subject do
     class TestRegistry
       include Puppet::Util::Windows::Registry
+      extend FFI::Library
+
+      ffi_lib :advapi32
+      attach_function :RegSetValueExW,
+        [:handle, :pointer, :dword, :dword, :pointer, :dword], :win32_long
+
+      def write_corrupt_dword(reg, valuename)
+        # Normally DWORDs contain 4 bytes.  This bad data only has 2
+        bad_data = [0, 0]
+        FFI::Pointer.from_string_to_wide_string(valuename) do |name_ptr|
+          FFI::MemoryPointer.new(:uchar, bad_data.length) do |data_ptr|
+            data_ptr.write_array_of_uchar(bad_data)
+            if RegSetValueExW(reg.hkey, name_ptr, 0,
+              Win32::Registry::REG_DWORD, data_ptr, data_ptr.size) != 0
+                raise Puppet::Util::Windows::Error.new("Failed to write registry value")
+            end
+          end
+        end
+      end
     end
 
     TestRegistry.new
@@ -109,7 +129,7 @@ describe Puppet::Util::Windows::Registry, :if => Puppet::Util::Platform.windows?
 
       let (:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
       let (:puppet_key) { "SOFTWARE\\Puppet Labs"}
-      let (:subkey_name) { "PuppetRegistryTest" }
+      let (:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
       let (:guid) { SecureRandom.uuid }
       let (:regsam) { Puppet::Util::Windows::Registry::KEY32 }
 
@@ -163,5 +183,75 @@ describe Puppet::Util::Windows::Registry, :if => Puppet::Util::Platform.windows?
         end
       end
     end
+
+    context "when reading values" do
+      let (:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
+      let (:puppet_key) { "SOFTWARE\\Puppet Labs"}
+      let (:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
+      let (:value_name) { SecureRandom.uuid }
+
+      after(:each) do
+        hklm.open(puppet_key, Win32::Registry::KEY_ALL_ACCESS) do |reg|
+          subject.delete_key(reg, subkey_name)
+        end
+      end
+
+      [
+        {:name => 'REG_SZ', :type => Win32::Registry::REG_SZ, :value => 'reg sz string'},
+        {:name => 'REG_EXPAND_SZ', :type => Win32::Registry::REG_EXPAND_SZ, :value => 'reg expand string'},
+        {:name => 'REG_MULTI_SZ', :type => Win32::Registry::REG_MULTI_SZ, :value => ['string1', 'string2']},
+        {:name => 'REG_BINARY', :type => Win32::Registry::REG_BINARY, :value => 'abinarystring'},
+        {:name => 'REG_DWORD', :type => Win32::Registry::REG_DWORD, :value => 0xFFFFFFFF},
+        {:name => 'REG_DWORD_BIG_ENDIAN', :type => Win32::Registry::REG_DWORD_BIG_ENDIAN, :value => 0xFFFF},
+        {:name => 'REG_QWORD', :type => Win32::Registry::REG_QWORD, :value => 0xFFFFFFFFFFFFFFFF},
+      ].each do |pair|
+        it "should return #{pair[:name]} values" do
+          hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS) do |reg|
+            reg.write(value_name, pair[:type], pair[:value])
+          end
+
+          hklm.open("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_READ) do |reg|
+            vals = subject.values(reg)
+
+            expect(vals).to have_key(value_name)
+            subject.each_value(reg) do |subkey, type, data|
+              expect(type).to eq(pair[:type])
+            end
+
+            written = vals[value_name]
+            expect(written).to eq(pair[:value])
+          end
+        end
+      end
+    end
+
+    context "when reading corrupt values" do
+      let (:hklm) { Win32::Registry::HKEY_LOCAL_MACHINE }
+      let (:puppet_key) { "SOFTWARE\\Puppet Labs"}
+      let (:subkey_name) { "PuppetRegistryTest#{SecureRandom.uuid}" }
+      let (:value_name) { SecureRandom.uuid }
+
+      before(:each) do
+        hklm.create("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS) do |reg_key|
+          subject.write_corrupt_dword(reg_key, value_name)
+        end
+      end
+
+      after(:each) do
+        hklm.open(puppet_key, Win32::Registry::KEY_ALL_ACCESS) do |reg_key|
+          subject.delete_key(reg_key, subkey_name)
+        end
+      end
+
+      it "should return nil for a corrupt DWORD" do
+        hklm.open("#{puppet_key}\\#{subkey_name}", Win32::Registry::KEY_ALL_ACCESS) do |reg_key|
+          vals = subject.values(reg_key)
+
+          expect(vals).to have_key(value_name)
+          expect(vals[value_name]).to be_nil
+        end
+      end
+    end
   end
 end
+end

data/spec/integration/util/windows/security_spec.rb

@@ -12,16 +12,20 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
   include PuppetSpec::Files
 
   before :all do
+
+    # necessary for localized name of guests
+    guests_name = Puppet::Util::Windows::SID.sid_to_name('S-1-5-32-546')
+    guests = Puppet::Util::Windows::ADSI::Group.new(guests_name)
+
     @sids = {
       :current_user => Puppet::Util::Windows::SID.name_to_sid(Puppet::Util::Windows::ADSI::User.current_user_name),
-      :system => Win32::Security::SID::LocalSystem,
-      :admin => Puppet::Util::Windows::SID.name_to_sid("Administrator"),
-      :administrators => Win32::Security::SID::BuiltinAdministrators,
-      :guest => Puppet::Util::Windows::SID.name_to_sid("Guest"),
-      :users => Win32::Security::SID::BuiltinUsers,
-      :power_users => Win32::Security::SID::PowerUsers,
-      :none => Win32::Security::SID::Nobody,
-      :everyone => Win32::Security::SID::Everyone
+      :system => Puppet::Util::Windows::SID::LocalSystem,
+      :administrators => Puppet::Util::Windows::SID::BuiltinAdministrators,
+      :guest => Puppet::Util::Windows::SID.name_to_sid(guests.members[0]),
+      :users => Puppet::Util::Windows::SID::BuiltinUsers,
+      :power_users => Puppet::Util::Windows::SID::PowerUsers,
+      :none => Puppet::Util::Windows::SID::Nobody,
+      :everyone => Puppet::Util::Windows::SID::Everyone
     }
     # The TCP/IP NetBIOS Helper service (aka 'lmhosts') has ended up
     # disabled on some VMs for reasons we couldn't track down. This
@@ -133,7 +137,10 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
           end
 
           it "should raise an exception when setting to a different user" do
-            expect { winsec.set_owner(sids[:guest], path) }.to raise_error(Puppet::Error, /This security ID may not be assigned as the owner of this object./)
+            expect { winsec.set_owner(sids[:guest], path) }.to raise_error do |error|
+              expect(error).to be_a(Puppet::Util::Windows::Error)
+              expect(error.code).to eq(1307) # ERROR_INVALID_OWNER
+            end
           end
         end
 
@@ -143,7 +150,10 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
           end
 
           it "should raise an exception if an invalid path is provided" do
-            expect { winsec.get_owner("c:\\doesnotexist.txt") }.to raise_error(Puppet::Error, /The system cannot find the file specified./)
+            expect { winsec.get_owner("c:\\doesnotexist.txt") }.to raise_error do |error|
+              expect(error).to be_a(Puppet::Util::Windows::Error)
+              expect(error.code).to eq(2) # ERROR_FILE_NOT_FOUND
+            end
           end
         end
 
@@ -165,7 +175,10 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
           end
 
           it "should raise an exception if an invalid path is provided" do
-            expect { winsec.get_group("c:\\doesnotexist.txt") }.to raise_error(Puppet::Error, /The system cannot find the file specified./)
+            expect { winsec.get_group("c:\\doesnotexist.txt") }.to raise_error do |error|
+              expect(error).to be_a(Puppet::Util::Windows::Error)
+              expect(error.code).to eq(2) # ERROR_FILE_NOT_FOUND
+            end
           end
         end
 
@@ -239,6 +252,24 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
               expect(ace.mask).to eq(klass::FILE_ALL_ACCESS)
               expect(ace).not_to be_inherited
             end
+
+            if Puppet::FileSystem.directory?(path)
+              system_aces.each do |ace|
+                expect(ace).to be_object_inherit
+                expect(ace).to be_container_inherit
+              end
+
+              # it's critically important that this file be default created
+              # and that this file not have it's owner / group / mode set by winsec
+              nested_file = File.join(path, 'nested_file')
+              File.new(nested_file, 'w').close
+
+              system_aces = winsec.get_aces_for_path_by_sid(nested_file, sids[:system])
+              # even when SYSTEM is the owner (in CI), there should be an inherited SYSTEM
+              expect(system_aces.any? do |ace|
+                ace.mask == klass::FILE_ALL_ACCESS && ace.inherited?
+              end).to be_truthy
+            end
           end
 
           describe "for modes that require deny aces" do
@@ -283,7 +314,10 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
           end
 
           it "should raise an exception if an invalid path is provided" do
-            expect { winsec.set_mode(sids[:guest], "c:\\doesnotexist.txt") }.to raise_error(Puppet::Error, /The system cannot find the file specified./)
+            expect { winsec.set_mode(sids[:guest], "c:\\doesnotexist.txt") }.to raise_error do |error|
+              expect(error).to be_a(Puppet::Util::Windows::Error)
+              expect(error.code).to eq(2) # ERROR_FILE_NOT_FOUND
+            end
           end
         end
 
@@ -327,7 +361,10 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
           end
 
           it "should raise an exception if an invalid path is provided" do
-            expect { winsec.get_mode("c:\\doesnotexist.txt") }.to raise_error(Puppet::Error, /The system cannot find the file specified./)
+            expect { winsec.get_mode("c:\\doesnotexist.txt") }.to raise_error do |error|
+              expect(error).to be_a(Puppet::Util::Windows::Error)
+              expect(error.code).to eq(2) # ERROR_FILE_NOT_FOUND
+            end
           end
         end
 
@@ -387,9 +424,14 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
         end
 
         describe "#owner=" do
+          it "should accept the guest sid" do
+            winsec.set_owner(sids[:guest], path)
+            expect(winsec.get_owner(path)).to eq(sids[:guest])
+          end
+
           it "should accept a user sid" do
-            winsec.set_owner(sids[:admin], path)
-            expect(winsec.get_owner(path)).to eq(sids[:admin])
+            winsec.set_owner(sids[:current_user], path)
+            expect(winsec.get_owner(path)).to eq(sids[:current_user])
           end
 
           it "should accept a group sid" do
@@ -402,19 +444,27 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
           end
 
           it "should raise an exception if an invalid path is provided" do
-            expect { winsec.set_owner(sids[:guest], "c:\\doesnotexist.txt") }.to raise_error(Puppet::Error, /The system cannot find the file specified./)
+            expect { winsec.set_owner(sids[:guest], "c:\\doesnotexist.txt") }.to raise_error do |error|
+              expect(error).to be_a(Puppet::Util::Windows::Error)
+              expect(error.code).to eq(2) # ERROR_FILE_NOT_FOUND
+            end
           end
         end
 
         describe "#group=" do
+          it "should accept the test group" do
+            winsec.set_group(sids[:guest], path)
+            expect(winsec.get_group(path)).to eq(sids[:guest])
+          end
+
           it "should accept a group sid" do
             winsec.set_group(sids[:power_users], path)
             expect(winsec.get_group(path)).to eq(sids[:power_users])
           end
 
           it "should accept a user sid" do
-            winsec.set_group(sids[:admin], path)
-            expect(winsec.get_group(path)).to eq(sids[:admin])
+            winsec.set_group(sids[:current_user], path)
+            expect(winsec.get_group(path)).to eq(sids[:current_user])
           end
 
           it "should combine owner and group rights when they are the same sid" do
@@ -436,7 +486,10 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
           end
 
           it "should raise an exception if an invalid path is provided" do
-            expect { winsec.set_group(sids[:guest], "c:\\doesnotexist.txt") }.to raise_error(Puppet::Error, /The system cannot find the file specified./)
+            expect { winsec.set_group(sids[:guest], "c:\\doesnotexist.txt") }.to raise_error do |error|
+              expect(error).to be_a(Puppet::Util::Windows::Error)
+              expect(error.code).to eq(2) # ERROR_FILE_NOT_FOUND
+            end
           end
         end
 
@@ -449,9 +502,10 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
           it "should retrieve the user sid" do
             sid = nil
             user = Puppet::Util::Windows::ADSI::User.create("puppet#{rand(10000)}")
+            user.password = 'PUPPET_RULeZ_123!'
             user.commit
             begin
-              sid = Puppet::Util::Windows::ADSI::User.new(user.name).sid.to_s
+              sid = Puppet::Util::Windows::ADSI::User.new(user.name).sid.sid
               winsec.set_owner(sid, path)
               winsec.set_mode(WindowsSecurityTester::S_IRWXU, path)
             ensure
@@ -467,7 +521,7 @@ describe "Puppet::Util::Windows::Security", :if => Puppet.features.microsoft_win
             group = Puppet::Util::Windows::ADSI::Group.create("puppet#{rand(10000)}")
             group.commit
             begin
-              sid = Puppet::Util::Windows::ADSI::Group.new(group.name).sid.to_s
+              sid = Puppet::Util::Windows::ADSI::Group.new(group.name).sid.sid
               winsec.set_group(sid, path)
               winsec.set_mode(WindowsSecurityTester::S_IRWXG, path)
             ensure

data/spec/integration/util/windows/user_spec.rb

@@ -67,7 +67,7 @@ describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows
         yield
       }.to raise_error { |error|
         expect(error).to be_a(Puppet::Util::Windows::Error)
-        # http://msdn.microsoft.com/en-us/library/windows/desktop/ms681385(v=vs.85).aspx
+        # https://msdn.microsoft.com/en-us/library/windows/desktop/ms681385(v=vs.85).aspx
         # ERROR_LOGON_FAILURE 1326
         expect(error.code).to eq(1326)
       }
@@ -106,13 +106,35 @@ describe "Puppet::Util::Windows::User", :if => Puppet.features.microsoft_windows
         expect(Puppet::Util::Windows::User.password_is?(username, bad_password)).to be_falsey
       end
 
-      it "should return false given an incorrect username and nil password" do
-        expect(Puppet::Util::Windows::User.password_is?(username, nil)).to be_falsey
-      end
-
       it "should return false given a nil username and an incorrect password" do
         expect(Puppet::Util::Windows::User.password_is?(nil, bad_password)).to be_falsey
       end
+
+      context "with a correct password" do
+        it "should return true even if account restrictions are in place " do
+          error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_ACCOUNT_RESTRICTION)
+          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
+          expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
+        end
+
+        it "should return true even for an account outside of logon hours" do
+          error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_INVALID_LOGON_HOURS)
+          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
+          expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
+        end
+
+        it "should return true even for an account not allowed to log into this workstation" do
+          error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_INVALID_WORKSTATION)
+          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
+          expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
+        end
+
+        it "should return true even for a disabled account" do
+          error = Puppet::Util::Windows::Error.new('', Puppet::Util::Windows::User::ERROR_ACCOUNT_DISABLED)
+          Puppet::Util::Windows::User.stubs(:logon_user).raises(error)
+          expect(Puppet::Util::Windows::User.password_is?(username, 'p@ssword')).to be(true)
+        end
+      end
     end
 
     describe "check_token_membership" do

data/spec/integration/util_spec.rb

@@ -27,9 +27,10 @@ describe Puppet::Util do
       expect { Puppet::Util::Execution.execute(command) }.to raise_error(Puppet::ExecutionFailure, /Execution of '#{command}' returned 43: /)
       expect($CHILD_STATUS.exitstatus).to eq(43)
     end
+  end
 
-    it "replace_file should preserve original ACEs from existing replaced file on Windows",
-      :if => Puppet.features.microsoft_windows? do
+  describe "#replace_file on Windows", :if => Puppet.features.microsoft_windows? do
+    it "replace_file should preserve original ACEs from existing replaced file on Windows" do
 
       file = tmpfile("somefile")
       FileUtils.touch(file)
@@ -54,8 +55,7 @@ describe Puppet::Util do
       expect(replaced_sd.dacl).to eq(expected_sd.dacl)
     end
 
-    it "replace_file should use reasonable default ACEs on a new file on Windows",
-      :if => Puppet.features.microsoft_windows? do
+    it "replace_file should use reasonable default ACEs on a new file on Windows" do
 
       dir = tmpdir('DACL_playground')
       protected_sd = Puppet::Util::Windows::Security.get_security_descriptor(dir)
@@ -76,36 +76,58 @@ describe Puppet::Util do
 
       expect(new_sd.dacl).to eq(expected_sd.dacl)
     end
-  end
 
-  it "replace_file should work with filenames that include - and . (PUP-1389)", :if => Puppet.features.microsoft_windows? do
-    expected_content = 'some content'
-    dir = tmpdir('ReplaceFile_playground')
-    destination_file = File.join(dir, 'some-file.xml')
+    it "replace_file should work with filenames that include - and . (PUP-1389)" do
+      expected_content = 'some content'
+      dir = tmpdir('ReplaceFile_playground')
+      destination_file = File.join(dir, 'some-file.xml')
+
+      Puppet::Util.replace_file(destination_file, nil) do |temp_file|
+          temp_file.open
+          temp_file.write(expected_content)
+      end
 
-    Puppet::Util.replace_file(destination_file, nil) do |temp_file|
-        temp_file.open
-        temp_file.write(expected_content)
+      actual_content = File.read(destination_file)
+      expect(actual_content).to eq(expected_content)
     end
 
-    actual_content = File.read(destination_file)
-    expect(actual_content).to eq(expected_content)
+    it "replace_file should work with filenames that include special characters (PUP-1389)" do
+      expected_content = 'some content'
+      dir = tmpdir('ReplaceFile_playground')
+      # http://www.fileformat.info/info/unicode/char/00e8/index.htm
+      # dest_name = "somèfile.xml"
+      dest_name = "som\u00E8file.xml"
+      destination_file = File.join(dir, dest_name)
+
+      Puppet::Util.replace_file(destination_file, nil) do |temp_file|
+          temp_file.open
+          temp_file.write(expected_content)
+      end
+
+      actual_content = File.read(destination_file)
+      expect(actual_content).to eq(expected_content)
+    end
   end
 
-  it "replace_file should work with filenames that include special characters (PUP-1389)", :if => Puppet.features.microsoft_windows? do
-    expected_content = 'some content'
-    dir = tmpdir('ReplaceFile_playground')
-    # http://www.fileformat.info/info/unicode/char/00e8/index.htm
-    # dest_name = "somèfile.xml"
-    dest_name = "som\u00E8file.xml"
-    destination_file = File.join(dir, dest_name)
-
-    Puppet::Util.replace_file(destination_file, nil) do |temp_file|
-        temp_file.open
-        temp_file.write(expected_content)
+  describe "#which on Windows", :if => Puppet.features.microsoft_windows? do
+    let (:rune_utf8) { "\u16A0\u16C7\u16BB\u16EB\u16D2\u16E6\u16A6\u16EB\u16A0\u16B1\u16A9\u16A0\u16A2\u16B1\u16EB\u16A0\u16C1\u16B1\u16AA\u16EB\u16B7\u16D6\u16BB\u16B9\u16E6\u16DA\u16B3\u16A2\u16D7" }
+    let (:filename) { 'foo.exe' }
+    let (:filepath) { File.expand_path('C:\\' + rune_utf8 + '\\' + filename) }
+
+    before :each do
+      FileTest.stubs(:file?).returns false
+      FileTest.stubs(:file?).with(filepath).returns true
+
+      FileTest.stubs(:executable?).returns false
+      FileTest.stubs(:executable?).with(filepath).returns true
     end
 
-    actual_content = File.read(destination_file)
-    expect(actual_content).to eq(expected_content)
+    it "should be able to use UTF8 characters in the path" do
+      path = "C:\\" + rune_utf8 + "#{File::PATH_SEPARATOR}c:\\windows\\system32#{File::PATH_SEPARATOR}c:\\windows"
+      Puppet::Util.withenv( { "PATH" => path } , :windows) do
+        expect(Puppet::Util.which(filename)).to eq(filepath)
+      end
+    end
   end
+
 end

data/spec/lib/matchers/include_in_order.rb

@@ -1,5 +1,4 @@
 RSpec::Matchers.define :include_in_order do |*expected|
-  include RSpec::Matchers::Pretty
 
   match do |actual|
     elements = expected.dup
@@ -12,10 +11,10 @@ RSpec::Matchers.define :include_in_order do |*expected|
   end
 
   def failure_message
-    "expected #{@actual.inspect} to include#{expected_to_sentence} in order"
+    "expected #{@actual.inspect} to include#{expected} in order"
   end
 
   def failure_message_when_negated
-    "expected #{@actual.inspect} not to include#{expected_to_sentence} in order"
+    "expected #{@actual.inspect} not to include#{expected} in order"
   end
 end

data/spec/lib/matchers/resource.rb

@@ -36,7 +36,7 @@ module Matchers; module Resource
       if resource = actual_catalog.resource(expected_resource)
         resource_match(expected_resource, resource)
       else
-        @mismatch = "expected #{@actual.to_dot} to include #{@expected[0]}"
+        @mismatch = "expected #{@actual.to_dot} to include #{expected_resource}"
         false
       end
     end
@@ -50,4 +50,25 @@ module Matchers; module Resource
       @mismatch
     end
   end
+
+
+  matcher :be_resource do |expected_resource|
+    def resource_match(expected_resource, actual_resource)
+      if actual_resource.ref == expected_resource
+        true
+      else
+        @mismatch = "expected #{expected_resource} but was #{actual_resource.ref}"
+        false
+      end
+    end
+
+    match do |actual_resource|
+      resource_match(expected_resource, actual_resource)
+    end
+
+    def failure_message
+      @mismatch
+    end
+  end
+
 end; end

data/spec/lib/puppet_spec/compiler.rb

@@ -1,14 +1,14 @@
 module PuppetSpec::Compiler
   module_function
 
-  def compile_to_catalog(string, node = Puppet::Node.new('foonode'))
+  def compile_to_catalog(string, node = Puppet::Node.new('test'))
     Puppet[:code] = string
     # see lib/puppet/indirector/catalog/compiler.rb#filter
     Puppet::Parser::Compiler.compile(node).filter { |r| r.virtual? }
   end
 
-  def compile_to_ral(manifest)
-    catalog = compile_to_catalog(manifest)
+  def compile_to_ral(manifest, node = Puppet::Node.new('test'))
+    catalog = compile_to_catalog(manifest, node)
     ral = catalog.to_ral
     ral.finalize
     ral
@@ -46,4 +46,33 @@ module PuppetSpec::Compiler
     relationships.traverse { |resource| order_seen << resource.ref }
     order_seen
   end
+
+  def collect_notices(code, node = Puppet::Node.new('foonode'))
+    Puppet[:code] = code
+    compiler = Puppet::Parser::Compiler.new(node)
+    node.environment.check_for_reparse
+    logs = []
+    Puppet::Util::Log.with_destination(Puppet::Test::LogCollector.new(logs)) do
+      yield(compiler)
+    end
+    logs = logs.select { |log| log.level == :notice }.map { |log| log.message }
+    logs
+  end
+
+  def eval_and_collect_notices(code, node = Puppet::Node.new('foonode'), topscope_vars = {})
+    collect_notices(code, node) do |compiler|
+      unless topscope_vars.empty?
+        scope = compiler.topscope
+        topscope_vars.each {|k,v| scope.setvar(k, v) }
+      end
+      if block_given?
+        compiler.compile do |catalog|
+          yield(compiler.topscope, catalog)
+          catalog
+        end
+      else
+        compiler.compile
+      end
+    end
+  end
 end

data/spec/lib/puppet_spec/files.rb

@@ -28,7 +28,7 @@ module PuppetSpec::Files
   def self.tmpfile(name, dir = nil)
     # Generate a temporary file, just for the name...
     source = dir ? Tempfile.new(name, dir) : Tempfile.new(name)
-    path = source.path
+    path = Puppet::FileSystem.expand_path(source.path.encode(Encoding::UTF_8))
     source.close!
 
     record_tmp(File.expand_path(path))
@@ -43,9 +43,23 @@ module PuppetSpec::Files
     file
   end
 
+  def script_containing(name, contents) PuppetSpec::Files.script_containing(name, contents) end
+  def self.script_containing(name, contents)
+    file = tmpfile(name)
+    if Puppet.features.microsoft_windows?
+      file += '.bat'
+      text = contents[:windows]
+    else
+      text = contents[:posix]
+    end
+    File.open(file, 'wb') { |f| f.write(text) }
+    Puppet::FileSystem.chmod(0755, file)
+    file
+  end
+
   def tmpdir(name) PuppetSpec::Files.tmpdir(name) end
   def self.tmpdir(name)
-    dir = Dir.mktmpdir(name)
+    dir = Puppet::FileSystem.expand_path(Dir.mktmpdir(name).encode!(Encoding::UTF_8))
 
     record_tmp(dir)
 

data/spec/lib/puppet_spec/matchers.rb

@@ -58,10 +58,10 @@ end
 RSpec::Matchers.define :have_printed do |expected|
 
   case expected
-    when String, Regexp
-      expected = expected
-    else
-      expected = expected.to_s
+  when String, Regexp, Proc
+    expected = expected
+  else
+    expected = expected.to_s
   end
 
   chain :and_exit_with do |code|
@@ -79,6 +79,8 @@ RSpec::Matchers.define :have_printed do |expected|
         actual.include?(expected)
       when Regexp
         expected.match(actual)
+      when Proc
+        expected.call(actual)
       else
         raise ArgumentError, "No idea how to match a #{actual.class.name}"
     end

data/spec/lib/puppet_spec/module_tool/shared_functions.rb

@@ -31,7 +31,7 @@ module PuppetSpec
         if options.nil?
           expect(release).to be_nil
         else
-          from = options.keys.find { |k| k.nil? || k.is_a?(Semantic::Version) }
+          from = options.keys.find { |k| k.nil? || k.is_a?(SemanticPuppet::Version) }
           to   = options.delete(from)
 
           if to or from
@@ -49,7 +49,7 @@ module PuppetSpec
       end
 
       def v(str)
-        Semantic::Version.parse(str)
+        SemanticPuppet::Version.parse(str)
       end
     end
   end

data/spec/lib/puppet_spec/module_tool/stub_source.rb

@@ -1,6 +1,6 @@
 module PuppetSpec
   module ModuleTool
-    class StubSource < Semantic::Dependency::Source
+    class StubSource < SemanticPuppet::Dependency::Source
       def inspect; "Stub Source"; end
       def host
         "http://nowhe.re"