puppet 2.7.3 → 2.7.4

data/spec/unit/resource/status_spec.rb

@@ -4,14 +4,16 @@ require 'spec_helper'
 require 'puppet/resource/status'
 
 describe Puppet::Resource::Status do
+  include PuppetSpec::Files
+
   before do
-    @resource = Puppet::Type.type(:file).new :path => "/my/file"
+    @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
     @status = Puppet::Resource::Status.new(@resource)
   end
 
   it "should compute type and title correctly" do
     @status.resource_type.should == "File"
-    @status.title.should == "/my/file"
+    @status.title.should == make_absolute("/my/file")
   end
 
   [:node, :file, :line, :current_values, :status, :evaluation_time].each do |attr|

data/spec/unit/resource_spec.rb

@@ -3,9 +3,10 @@ require 'spec_helper'
 require 'puppet/resource'
 
 describe Puppet::Resource do
+  include PuppetSpec::Files
 
   before do
-    @basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
+    @basepath = make_absolute("/somepath")
   end
 
   [:catalog, :file, :line].each do |attr|
@@ -106,9 +107,8 @@ describe Puppet::Resource do
   end
 
   it "should fail if the title is a hash and the type is not a valid resource reference string" do
-    lambda { Puppet::Resource.new({:type => "foo", :title => "bar"}) }.should raise_error(ArgumentError,
-      'Puppet::Resource.new does not take a hash as the first argument. Did you mean ("foo", "bar") ?'
-    )
+    expect { Puppet::Resource.new({:type => "foo", :title => "bar"}) }.
+      to raise_error ArgumentError, /Puppet::Resource.new does not take a hash/
   end
 
   it "should be able to produce a backward-compatible reference array" do
@@ -778,7 +778,7 @@ type: File
     end
 
     it "should have a default terminus" do
-      Puppet::Resource.indirection.terminus_class.should == :ral
+      Puppet::Resource.indirection.terminus_class.should be
     end
 
     it "should have a name" do

data/spec/unit/simple_graph_spec.rb

@@ -1,8 +1,4 @@
 #!/usr/bin/env rspec
-#
-#  Created by Luke Kanies on 2007-11-1.
-#  Copyright (c) 2006. All rights reserved.
-
 require 'spec_helper'
 require 'puppet/simple_graph'
 

data/spec/unit/ssl/certificate_authority_spec.rb

@@ -5,7 +5,7 @@ require 'puppet/ssl/certificate_authority'
 
 describe Puppet::SSL::CertificateAuthority do
   after do
-    Puppet::Util::Cacher.expire
+    Puppet::SSL::CertificateAuthority.instance_variable_set(:@singleton_instance, nil)
     Puppet.settings.clearused
   end
 
@@ -25,7 +25,7 @@ describe Puppet::SSL::CertificateAuthority do
   describe "when finding an existing instance" do
     describe "and the host is a CA host and the run_mode is master" do
       before do
-        Puppet.settings.stubs(:value).with(:ca).returns true
+        Puppet[:ca] = true
         Puppet.run_mode.stubs(:master?).returns true
 
         @ca = mock('ca')

data/spec/unit/ssl/host_spec.rb

@@ -5,15 +5,24 @@ require 'puppet/ssl/host'
 require 'puppet/sslcertificates'
 require 'puppet/sslcertificates/ca'
 
-describe Puppet::SSL::Host do
+# REMIND: Fails on windows because there is no user provider yet
+describe Puppet::SSL::Host, :fails_on_windows => true do
+  include PuppetSpec::Files
+
   before do
     Puppet::SSL::Host.indirection.terminus_class = :file
+
+    # Get a safe temporary file
+    dir = tmpdir("ssl_host_testing")
+    Puppet.settings[:confdir] = dir
+    Puppet.settings[:vardir] = dir
+
     @host = Puppet::SSL::Host.new("myname")
   end
 
   after do
     # Cleaned out any cached localhost instance.
-    Puppet::Util::Cacher.expire
+    Puppet::SSL::Host.instance_variable_set(:@localhost, nil)
     Puppet::SSL::Host.ca_location = :none
   end
 
@@ -82,16 +91,6 @@ describe Puppet::SSL::Host do
     Puppet::SSL::Host.localhost.should == Puppet::SSL::Host.localhost
   end
 
-  it "should be able to expire the cached instance" do
-    one = stub 'host1', :certificate => "eh", :key => 'foo'
-    two = stub 'host2', :certificate => "eh", :key => 'foo'
-    Puppet::SSL::Host.expects(:new).times(2).returns(one).then.returns(two)
-
-    Puppet::SSL::Host.localhost.should equal(one)
-    Puppet::Util::Cacher.expire
-    Puppet::SSL::Host.localhost.should equal(two)
-  end
-
   it "should be able to verify its certificate matches its key" do
     Puppet::SSL::Host.new("foo").should respond_to(:certificate_matches_key?)
   end
@@ -711,7 +710,7 @@ describe Puppet::SSL::Host do
     end
   end
 
-  describe "when handling PSON" do
+  describe "when handling PSON", :unless => Puppet.features.microsoft_windows? do
     include PuppetSpec::Files
 
     before do

data/spec/unit/ssl/inventory_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 require 'puppet/ssl/inventory'
 
-describe Puppet::SSL::Inventory do
+describe Puppet::SSL::Inventory, :unless => Puppet.features.microsoft_windows? do
   before do
     @class = Puppet::SSL::Inventory
   end
@@ -118,7 +118,7 @@ describe Puppet::SSL::Inventory do
       end
     end
 
-    describe "and formatting a certificate" do
+    describe "and formatting a certificate", :fails_on_windows => true do
       before do
         @cert = stub 'cert', :not_before => Time.now, :not_after => Time.now, :subject => "mycert", :serial => 15
       end

data/spec/unit/sslcertificates/ca_spec.rb

@@ -5,27 +5,23 @@ require 'puppet'
 require 'puppet/sslcertificates'
 require 'puppet/sslcertificates/ca'
 
-describe Puppet::SSLCertificates::CA do
+describe Puppet::SSLCertificates::CA, :unless => Puppet.features.microsoft_windows? do
+  include PuppetSpec::Files
+
   before :all do
     @hosts = %w{host.domain.com Other.Testing.Com}
   end
 
   before :each do
     Puppet::Util::SUIDManager.stubs(:asuser).yields
-    file = Tempfile.new("ca_testing")
-    @dir = file.path
-    file.delete
+    dir = tmpdir("ca_testing")
 
-    Puppet.settings[:confdir] = @dir
-    Puppet.settings[:vardir]  = @dir
+    Puppet.settings[:confdir] = dir
+    Puppet.settings[:vardir]  = dir
 
     @ca = Puppet::SSLCertificates::CA.new
   end
 
-  after :each do
-    system("rm -rf #{@dir}")
-  end
-
   describe 'when cleaning' do
     it 'should remove associated files' do
       dirs = [:csrdir, :signeddir, :publickeydir, :privatekeydir, :certdir]

data/spec/unit/transaction/event_manager_spec.rb

@@ -4,6 +4,8 @@ require 'spec_helper'
 require 'puppet/transaction/event_manager'
 
 describe Puppet::Transaction::EventManager do
+  include PuppetSpec::Files
+
   describe "at initialization" do
     it "should require a transaction" do
       Puppet::Transaction::EventManager.new("trans").transaction.should == "trans"
@@ -23,7 +25,7 @@ describe Puppet::Transaction::EventManager do
     before do
       @manager = Puppet::Transaction::EventManager.new(@transaction)
 
-      @resource = Puppet::Type.type(:file).new :path => "/my/file"
+      @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
 
       @graph = stub 'graph', :matching_edges => [], :resource => @resource
       @manager.stubs(:relationship_graph).returns @graph
@@ -139,7 +141,7 @@ describe Puppet::Transaction::EventManager do
       @manager = Puppet::Transaction::EventManager.new(@transaction)
       @manager.stubs(:queue_events)
 
-      @resource = Puppet::Type.type(:file).new :path => "/my/file"
+      @resource = Puppet::Type.type(:file).new :path => make_absolute("/my/file")
       @event = Puppet::Transaction::Event.new(:name => :event, :resource => @resource)
     end
 

data/spec/unit/transaction/event_spec.rb

@@ -4,6 +4,8 @@ require 'spec_helper'
 require 'puppet/transaction/event'
 
 describe Puppet::Transaction::Event do
+  include PuppetSpec::Files
+
   [:previous_value, :desired_value, :property, :resource, :name, :message, :file, :line, :tags, :audited].each do |attr|
     it "should support #{attr}", :'fails_on_ruby_1.9.2' => true do
       event = Puppet::Transaction::Event.new
@@ -113,7 +115,7 @@ describe Puppet::Transaction::Event do
 
   describe "When converting to YAML" do
     it "should include only documented attributes" do
-      resource = Puppet::Type.type(:file).new(:title => "/tmp/foo")
+      resource = Puppet::Type.type(:file).new(:title => make_absolute("/tmp/foo"))
       event = Puppet::Transaction::Event.new(:source_description => "/my/param", :resource => resource,
                                              :file => "/foo.rb", :line => 27, :tags => %w{one two},
                                              :desired_value => 7, :historical_value => 'Brazil',

data/spec/unit/transaction/report_spec.rb

@@ -103,10 +103,6 @@ describe Puppet::Transaction::Report do
       report.expects(:host).returns "me"
       report.name.should == "me"
     end
-
-    after do
-      Puppet::Util::Cacher.expire
-    end
   end
 
   describe "when computing exit status" do
@@ -154,7 +150,7 @@ describe Puppet::Transaction::Report do
 
     def add_statuses(count, type = :file)
       count.times do |i|
-        status = Puppet::Resource::Status.new(Puppet::Type.type(type).new(:title => "/my/path#{i}"))
+        status = Puppet::Resource::Status.new(Puppet::Type.type(type).new(:title => make_absolute("/my/path#{i}")))
         yield status if block_given?
         @report.add_resource_status status
       end
@@ -208,7 +204,7 @@ describe Puppet::Transaction::Report do
     end
 
     describe "for times" do
-      it "should provide the total amount of time for each resource type" do
+      it "should provide the total amount of time for each resource type", :fails_on_windows => true do
         add_statuses(3, :file) do |status|
           status.evaluation_time = 1
         end

data/spec/unit/transaction/resource_harness_spec.rb

@@ -7,10 +7,14 @@ describe Puppet::Transaction::ResourceHarness do
   include PuppetSpec::Files
 
   before do
+    @mode_750 = Puppet.features.microsoft_windows? ? '644' : '750'
+    @mode_755 = Puppet.features.microsoft_windows? ? '644' : '755'
+    path = make_absolute("/my/file")
+
     @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
-    @resource = Puppet::Type.type(:file).new :path => "/my/file"
+    @resource = Puppet::Type.type(:file).new :path => path
     @harness = Puppet::Transaction::ResourceHarness.new(@transaction)
-    @current_state = Puppet::Resource.new(:file, "/my/file")
+    @current_state = Puppet::Resource.new(:file, path)
     @resource.stubs(:retrieve).returns @current_state
     @status = Puppet::Resource::Status.new(@resource)
     Puppet::Resource::Status.stubs(:new).returns @status
@@ -148,8 +152,8 @@ describe Puppet::Transaction::ResourceHarness do
 
   describe "when applying changes" do
     [false, true].each do |noop_mode|; describe (noop_mode ? "in noop mode" : "in normal mode") do
-      [nil, '750'].each do |machine_state|; describe (machine_state ? "with a file initially present" : "with no file initially present") do
-        [nil, '750', '755'].each do |yaml_mode|
+      [nil, @mode_750].each do |machine_state|; describe (machine_state ? "with a file initially present" : "with no file initially present") do
+        [nil, @mode_750, @mode_755].each do |yaml_mode|
           [nil, :file, :absent].each do |yaml_ensure|; describe "with mode=#{yaml_mode.inspect} and ensure=#{yaml_ensure.inspect} stored in state.yml" do
             [false, true].each do |auditing_ensure|
               [false, true].each do |auditing_mode|
@@ -157,7 +161,7 @@ describe Puppet::Transaction::ResourceHarness do
                 auditing.push(:mode) if auditing_mode
                 auditing.push(:ensure) if auditing_ensure
                 [nil, :file, :absent].each do |ensure_property| # what we set "ensure" to in the manifest
-                  [nil, '750', '755'].each do |mode_property| # what we set "mode" to in the manifest
+                  [nil, @mode_750, @mode_755].each do |mode_property| # what we set "mode" to in the manifest
                     manifest_settings = {}
                     manifest_settings[:audit] = auditing if !auditing.empty?
                     manifest_settings[:ensure] = ensure_property if ensure_property

data/spec/unit/transaction_spec.rb

@@ -11,8 +11,10 @@ def without_warnings
 end
 
 describe Puppet::Transaction do
+  include PuppetSpec::Files
+
   before do
-    @basepath = Puppet.features.posix? ? "/what/ever" : "C:/tmp"
+    @basepath = make_absolute("/what/ever")
     @transaction = Puppet::Transaction.new(Puppet::Resource::Catalog.new)
   end
 

data/spec/unit/type/cron_spec.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe Puppet::Type.type(:cron) do
+describe Puppet::Type.type(:cron), :unless => Puppet.features.microsoft_windows? do
   before do
     @class = Puppet::Type.type(:cron)
 

data/spec/unit/type/exec_spec.rb

@@ -2,9 +2,9 @@
 require 'spec_helper'
 
 describe Puppet::Type.type(:exec) do
+  include PuppetSpec::Files
+
   def exec_tester(command, exitstatus = 0, rest = {})
-    @user_name  = 'some_user_name'
-    @group_name = 'some_group_name'
     Puppet.features.stubs(:root?).returns(true)
 
     output = rest.delete(:output) || ''
@@ -13,8 +13,6 @@ describe Puppet::Type.type(:exec) do
     args = {
       :name      => command,
       :path      => @example_path,
-      :user      => @user_name,
-      :group     => @group_name,
       :logoutput => false,
       :loglevel  => :err,
       :returns   => 0
@@ -24,24 +22,30 @@ describe Puppet::Type.type(:exec) do
 
     status = stub "process", :exitstatus => exitstatus
     Puppet::Util::SUIDManager.expects(:run_and_capture).times(tries).
-      with([command], @user_name, @group_name).returns([output, status])
+      with(command, nil, nil).returns([output, status])
 
     return exec
   end
 
   before do
-    @command = Puppet.features.posix? ? '/bin/true whatever' : '"C:/Program Files/something.exe" whatever'
+    @command = make_absolute('/bin/true whatever')
+    @executable = make_absolute('/bin/true')
+    @bogus_cmd = make_absolute('/bogus/cmd')
   end
 
   describe "when not stubbing the provider" do
     before do
-      @executable = Puppet.features.posix? ? '/bin/true' : 'C:/Program Files/something.exe'
-      File.stubs(:exists?).returns false
-      File.stubs(:exists?).with(@executable).returns true
-      File.stubs(:exists?).with('/bin/false').returns true
-      @example_path = Puppet.features.posix? ? %w{/usr/bin /bin} : [ "C:/Program Files/something/bin", "C:/Ruby/bin" ]
-      File.stubs(:exists?).with(File.join(@example_path[0],"true")).returns true
-      File.stubs(:exists?).with(File.join(@example_path[0],"false")).returns true
+      path = tmpdir('path')
+      true_cmd = File.join(path, 'true')
+      false_cmd = File.join(path, 'false')
+
+      FileUtils.touch(true_cmd)
+      FileUtils.touch(false_cmd)
+
+      File.chmod(0755, true_cmd)
+      File.chmod(0755, false_cmd)
+
+      @example_path = [path]
     end
 
     it "should return :executed_command as its event" do
@@ -140,10 +144,11 @@ describe Puppet::Type.type(:exec) do
   end
 
   it "should be able to autorequire files mentioned in the command" do
+    foo = make_absolute('/bin/foo')
     catalog = Puppet::Resource::Catalog.new
-    tmp = Puppet::Type.type(:file).new(:name => "/bin/foo")
+    tmp = Puppet::Type.type(:file).new(:name => foo)
     catalog.add_resource tmp
-    execer = Puppet::Type.type(:exec).new(:name => "/bin/foo")
+    execer = Puppet::Type.type(:exec).new(:name => foo)
     catalog.add_resource execer
 
     catalog.relationship_graph.dependencies(execer).should == [tmp]
@@ -151,21 +156,37 @@ describe Puppet::Type.type(:exec) do
 
   describe "when handling the path parameter" do
     expect = %w{one two three four}
-    { "an array"                        => expect,
-      "a colon separated list"          => "one:two:three:four",
-      "a semi-colon separated list"     => "one;two;three;four",
-      "both array and colon lists"      => ["one", "two:three", "four"],
-      "both array and semi-colon lists" => ["one", "two;three", "four"],
-      "colon and semi-colon lists"      => ["one:two", "three;four"]
+    { "an array"                                      => expect,
+      "a path-separator delimited list"               => expect.join(File::PATH_SEPARATOR),
+      "both array and path-separator delimited lists" => ["one", "two#{File::PATH_SEPARATOR}three", "four"],
     }.each do |test, input|
       it "should accept #{test}" do
         type = Puppet::Type.type(:exec).new(:name => @command, :path => input)
         type[:path].should == expect
       end
     end
+
+    describe "on platforms where path separator is not :" do
+      before :each do
+        @old_verbosity = $VERBOSE
+        $VERBOSE = nil
+        @old_separator = File::PATH_SEPARATOR
+        File::PATH_SEPARATOR = 'q'
+      end
+
+      after :each do
+        File::PATH_SEPARATOR = @old_separator
+        $VERBOSE = @old_verbosity
+      end
+
+      it "should use the path separator of the current platform" do
+        type = Puppet::Type.type(:exec).new(:name => @command, :path => "fooqbarqbaz")
+        type[:path].should == %w[foo bar baz]
+      end
+    end
   end
 
-  describe "when setting user" do
+  describe "when setting user", :fails_on_windows => true do
     it "should fail if we are not root" do
       Puppet.features.stubs(:root?).returns(false)
       expect { Puppet::Type.type(:exec).new(:name => @command, :user => 'input') }.
@@ -184,7 +205,7 @@ describe Puppet::Type.type(:exec) do
   describe "when setting group" do
     shared_examples_for "exec[:group]" do
       ['one', 2, 'wheel', 4294967295, 4294967296].each do |value|
-        it "should accept '#{value}' without error or judgement" do
+        it "should accept '#{value}' without error or judgement", :fails_on_windows => true do
           type = Puppet::Type.type(:exec).new(:name => @command, :group => value)
           type[:group].should == value
         end
@@ -205,7 +226,8 @@ describe Puppet::Type.type(:exec) do
   describe "when setting cwd" do
     it_should_behave_like "all path parameters", :cwd, :array => false do
       def instance(path)
-        Puppet::Type.type(:exec).new(:name => '/bin/true', :cwd => path)
+        # Specify shell provider so we don't have to care about command validation
+        Puppet::Type.type(:exec).new(:name => @executable, :cwd => path, :provider => :shell)
       end
     end
   end
@@ -221,7 +243,7 @@ describe Puppet::Type.type(:exec) do
           if @param == :name then
             instance = Puppet::Type.type(:exec).new()
           else
-            instance = Puppet::Type.type(:exec).new(:name => "/bin/true")
+            instance = Puppet::Type.type(:exec).new(:name => @executable)
           end
           if valid then
             instance.provider.expects(:validatecmd).returns(true)
@@ -246,7 +268,7 @@ describe Puppet::Type.type(:exec) do
   shared_examples_for "all exec command parameters that take arrays" do |param|
     describe "when given an array of inputs" do
       before :each do
-        @test = Puppet::Type.type(:exec).new(:name => "/bin/true")
+        @test = Puppet::Type.type(:exec).new(:name => @executable)
       end
 
       it "should accept the array when all commands return valid" do
@@ -281,7 +303,7 @@ describe Puppet::Type.type(:exec) do
 
   describe "for simple parameters" do
     before :each do
-      @exec = Puppet::Type.type(:exec).new(:name => '/bin/true')
+      @exec = Puppet::Type.type(:exec).new(:name => @executable)
     end
 
     describe "when setting environment" do
@@ -330,21 +352,30 @@ describe Puppet::Type.type(:exec) do
         end
       end
 
-      it "should fail if timeout is exceeded" do
-        File.stubs(:exists?).with('/bin/sleep').returns(true)
-        File.stubs(:exists?).with('sleep').returns(false)
+      it "should fail if timeout is exceeded", :fails_on_windows => true do
+        Puppet::Util.stubs(:execute).with do |cmd,args|
+          sleep 1
+          true
+        end
+        FileTest.stubs(:file?).returns(false)
+        FileTest.stubs(:file?).with('/bin/sleep').returns(true)
+        FileTest.stubs(:executable?).returns(false)
+        FileTest.stubs(:executable?).with('/bin/sleep').returns(true)
         sleep_exec = Puppet::Type.type(:exec).new(:name => 'sleep 1', :path => ['/bin'], :timeout => '0.2')
+
         lambda { sleep_exec.refresh }.should raise_error Puppet::Error, "Command exceeded timeout"
       end
 
       it "should convert timeout to a float" do
-        resource = Puppet::Type.type(:exec).new :command => "/bin/false", :timeout => "12"
+        command = make_absolute('/bin/false')
+        resource = Puppet::Type.type(:exec).new :command => command, :timeout => "12"
         resource[:timeout].should be_a(Float)
         resource[:timeout].should == 12.0
       end
 
       it "should munge negative timeouts to 0.0" do
-        resource = Puppet::Type.type(:exec).new :command => "/bin/false", :timeout => "-12.0"
+        command = make_absolute('/bin/false')
+        resource = Puppet::Type.type(:exec).new :command => command, :timeout => "-12.0"
         resource.parameter(:timeout).value.should be_a(Float)
         resource.parameter(:timeout).value.should == 0.0
       end
@@ -442,7 +473,8 @@ describe Puppet::Type.type(:exec) do
     describe "when setting creates" do
       it_should_behave_like "all path parameters", :creates, :array => true do
         def instance(path)
-          Puppet::Type.type(:exec).new(:name => '/bin/true', :creates => path)
+          # Specify shell provider so we don't have to care about command validation
+          Puppet::Type.type(:exec).new(:name => @executable, :creates => path, :provider => :shell)
         end
       end
     end
@@ -460,7 +492,7 @@ describe Puppet::Type.type(:exec) do
 
   describe "#check" do
     before :each do
-      @test = Puppet::Type.type(:exec).new(:name => "/bin/true")
+      @test = Puppet::Type.type(:exec).new(:name => @executable)
     end
 
     describe ":refreshonly" do
@@ -473,10 +505,10 @@ describe Puppet::Type.type(:exec) do
     end
 
     describe ":creates" do
-      before :all do
-        @exist   = "/"
-        @unexist = "/this/path/should/never/exist"
-        while FileTest.exist?(@unexist) do @unexist += "/foo" end
+      before :each do
+        @exist   = tmpfile('exist')
+        FileUtils.touch(@exist)
+        @unexist = tmpfile('unexist')
       end
 
       context "with a single item" do
@@ -525,8 +557,8 @@ describe Puppet::Type.type(:exec) do
     }.each do |param, sense|
       describe ":#{param}" do
         before :each do
-          @pass = "/magic/pass"
-          @fail = "/magic/fail"
+          @pass = make_absolute("/magic/pass")
+          @fail = make_absolute("/magic/fail")
 
           @pass_status = stub('status', :exitstatus => sense[:pass] ? 0 : 1)
           @fail_status = stub('status', :exitstatus => sense[:fail] ? 0 : 1)
@@ -584,9 +616,9 @@ describe Puppet::Type.type(:exec) do
     end
   end
 
-  describe "#retrieve" do
+  describe "#retrieve", :fails_on_windows => true do
     before :each do
-      @exec_resource = Puppet::Type.type(:exec).new(:name => "/bogus/cmd")
+      @exec_resource = Puppet::Type.type(:exec).new(:name => @bogus_cmd)
     end
 
     it "should return :notrun when check_all_attributes returns true" do
@@ -608,7 +640,7 @@ describe Puppet::Type.type(:exec) do
 
   describe "#output" do
     before :each do
-      @exec_resource = Puppet::Type.type(:exec).new(:name => "/bogus/cmd")
+      @exec_resource = Puppet::Type.type(:exec).new(:name => @bogus_cmd)
     end
 
     it "should return the provider's run output" do
@@ -625,14 +657,15 @@ describe Puppet::Type.type(:exec) do
 
   describe "#refresh" do
     before :each do
-      @exec_resource = Puppet::Type.type(:exec).new(:name => "/bogus/cmd")
+      @exec_resource = Puppet::Type.type(:exec).new(:name => @bogus_cmd)
     end
 
     it "should call provider run with the refresh parameter if it is set" do
+      myother_bogus_cmd = make_absolute('/myother/bogus/cmd')
       provider = stub 'provider'
       @exec_resource.stubs(:provider).returns(provider)
-      @exec_resource.stubs(:[]).with(:refresh).returns('/myother/bogus/cmd')
-      provider.expects(:run).with('/myother/bogus/cmd')
+      @exec_resource.stubs(:[]).with(:refresh).returns(myother_bogus_cmd)
+      provider.expects(:run).with(myother_bogus_cmd)
 
       @exec_resource.refresh
     end
@@ -641,7 +674,7 @@ describe Puppet::Type.type(:exec) do
       provider = stub 'provider'
       status = stubs "process_status"
       status.stubs(:exitstatus).returns("0")
-      provider.expects(:run).with('/bogus/cmd').returns(["silly output", status])
+      provider.expects(:run).with(@bogus_cmd).returns(["silly output", status])
       @exec_resource.stubs(:provider).returns(provider)
 
       @exec_resource.refresh

data/spec/unit/type/file/checksum_spec.rb

@@ -4,7 +4,8 @@ require 'spec_helper'
 checksum = Puppet::Type.type(:file).attrclass(:checksum)
 describe checksum do
   before do
-    @resource = Puppet::Type.type(:file).new :path => "/foo/bar"
+    @path = Puppet.features.microsoft_windows? ? "c:/foo/bar" : "/foo/bar"
+    @resource = Puppet::Type.type(:file).new :path => @path
     @checksum = @resource.parameter(:checksum)
   end
 
@@ -35,25 +36,25 @@ describe checksum do
 
   it "should use its current value when asked to sum a file's content" do
     @checksum.value = :md5lite
-    @checksum.expects(:md5lite_file).with("/foo/bar").returns "yay"
-    @checksum.sum_file("/foo/bar")
+    @checksum.expects(:md5lite_file).with(@path).returns "yay"
+    @checksum.sum_file(@path)
   end
 
   it "should use :md5 to sum a file when no value is set" do
-    @checksum.expects(:md5_file).with("/foo/bar").returns "yay"
-    @checksum.sum_file("/foo/bar")
+    @checksum.expects(:md5_file).with(@path).returns "yay"
+    @checksum.sum_file(@path)
   end
 
   it "should convert all sums to strings when summing files" do
     @checksum.value = :mtime
-    @checksum.expects(:mtime_file).with("/foo/bar").returns Time.now
-    lambda { @checksum.sum_file("/foo/bar") }.should_not raise_error
+    @checksum.expects(:mtime_file).with(@path).returns Time.now
+    lambda { @checksum.sum_file(@path) }.should_not raise_error
   end
 
   it "should return the summed contents of a file with a checksum label" do
     @resource[:checksum] = :md5
     @checksum.expects(:md5_file).returns "mysum"
-    @checksum.sum_file("/foo/bar").should == "{md5}mysum"
+    @checksum.sum_file(@path).should == "{md5}mysum"
   end
 
   it "should return the summed contents of a stream with a checksum label" do