puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/type/zpool_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 zpool = Puppet::Type.type(:zpool)

data/spec/unit/type_spec.rb

@@ -1,7 +1,8 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
-describe Puppet::Type, :fails_on_windows => true do
+
+describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   it "should be Comparable" do
@@ -27,7 +28,7 @@ describe Puppet::Type, :fails_on_windows => true do
   end
 
   it "should consider a parameter to be valid if it is a valid parameter" do
-    Puppet::Type.type(:mount).should be_valid_parameter(:path)
+    Puppet::Type.type(:mount).should be_valid_parameter(:name)
   end
 
   it "should consider a parameter to be valid if it is a valid property" do
@@ -283,13 +284,6 @@ describe Puppet::Type, :fails_on_windows => true do
   end
 
   describe "when initializing" do
-    describe "and passed a TransObject" do
-      it "should fail" do
-        trans = Puppet::TransObject.new("/foo", :mount)
-        expect { Puppet::Type.type(:mount).new(trans) }.to raise_error(Puppet::DevError)
-      end
-    end
-
     describe "and passed a Puppet::Resource instance" do
       it "should set its title to the title of the resource if the resource type is equal to the current type" do
         resource = Puppet::Resource.new(:mount, "/foo", :parameters => {:name => "/other"})
@@ -523,6 +517,32 @@ describe Puppet::Type, :fails_on_windows => true do
     end
   end
 
+  describe "#to_resource" do
+    it "should return a Puppet::Resource that includes properties, parameters and tags" do
+      type_resource = Puppet::Type.type(:mount).new(
+        :ensure   => :present,
+        :name     => "foo",
+        :fstype   => "bar",
+        :remounts => true
+      )
+      type_resource.tags = %w{bar baz}
+
+      # If it's not a property it's a parameter
+      type_resource.parameters[:remounts].should_not be_a(Puppet::Property)
+      type_resource.parameters[:fstype].is_a?(Puppet::Property).should be_true
+
+      type_resource.property(:ensure).expects(:retrieve).returns :present
+      type_resource.property(:fstype).expects(:retrieve).returns 15
+
+      resource = type_resource.to_resource
+
+      resource.should be_a Puppet::Resource
+      resource[:fstype].should   == 15
+      resource[:remounts].should == :true
+      resource.tags.should       =~ %w{foo bar baz mount}
+    end
+  end
+
   describe ".title_patterns" do
     describe "when there's one namevar" do
       before do
@@ -609,21 +629,68 @@ describe Puppet::Type, :fails_on_windows => true do
   end
 
   describe "::instances" do
-    it "should not fail if no suitable providers are found" do
-      fake_type = Puppet::Type.newtype(:type_spec_fake_type) do
+    after :each do Puppet::Type.rmtype(:type_spec_fake_type) end
+    let :type do
+      Puppet::Type.newtype(:type_spec_fake_type) do
         newparam(:name) do
           isnamevar
         end
-        newproperty(:prop1) do
-        end
 
-        provide(:fake1) do
-          confine :exists => '/no/such/file'
+        newproperty(:prop1) {}
+      end
+
+      Puppet::Type.type(:type_spec_fake_type)
+    end
+
+    it "should not fail if no suitable providers are found" do
+      type.provide(:fake1) do
+        confine :exists => '/no/such/file'
+        mk_resource_methods
+      end
+
+      expect { type.instances.should == [] }.to_not raise_error
+    end
+
+    context "with a default provider" do
+      before :each do
+        type.provide(:default) do
+          defaultfor :operatingsystem => Facter.value(:operatingsystem)
           mk_resource_methods
+          class << self
+            attr_accessor :names
+          end
+          def self.instance(name)
+            new(:name => name, :ensure => :present)
+          end
+          def self.instances
+            @instances ||= names.collect { |name| instance(name.to_s) }
+          end
+
+          @names = [:one, :two]
         end
       end
 
-      expect { fake_type.instances }.to_not raise_error
+      it "should return only instances of the type" do
+        type.instances.should be_all {|x| x.is_a? type }
+      end
+
+      it "should return instances from the default provider" do
+        type.instances.map(&:name).should == ["one", "two"]
+      end
+
+      it "should return instances from all providers" do
+        type.provide(:fake1, :parent => :default) { @names = [:three, :four] }
+        type.instances.map(&:name).should == ["one", "two", "three", "four"]
+      end
+
+      it "should not return instances from unsuitable providers" do
+        type.provide(:fake1, :parent => :default) do
+          @names = [:three, :four]
+          confine :exists => "/no/such/file"
+        end
+
+        type.instances.map(&:name).should == ["one", "two"]
+      end
     end
   end
 
@@ -669,10 +736,10 @@ describe Puppet::Type::RelationshipMetaparam do
     Puppet::Type::RelationshipMetaparam.should respond_to(:subclasses)
   end
 
-  describe "when munging relationships", :fails_on_windows => true do
+  describe "when munging relationships" do
     before do
-      @path = make_absolute('/foo')
-      @resource = Puppet::Type.type(:mount).new :name => @path
+      @path = File.expand_path('/foo')
+      @resource = Puppet::Type.type(:file).new :name => @path
       @metaparam = Puppet::Type.metaparamclass(:require).new :resource => @resource
     end
 
@@ -705,17 +772,6 @@ describe Puppet::Type::RelationshipMetaparam do
   end
 end
 
-describe Puppet::Type.metaparamclass(:check) do
-  include PuppetSpec::Files
-
-  it "should warn and create an instance of ':audit'" do
-    file = Puppet::Type.type(:file).new :path => make_absolute('/foo')
-    file.expects(:warning)
-    file[:check] = :mode
-    file[:audit].should == [:mode]
-  end
-end
-
 describe Puppet::Type.metaparamclass(:audit) do
   include PuppetSpec::Files
 
@@ -771,4 +827,97 @@ describe Puppet::Type.metaparamclass(:audit) do
       res.uniqueness_key.should == [ nil, 'root', myfile]
     end
   end
+
+  context "type attribute bracket methods" do
+    after :each do Puppet::Type.rmtype(:attributes)     end
+    let   :type do
+      Puppet::Type.newtype(:attributes) do
+        newparam(:name) {}
+      end
+    end
+
+    it "should work with parameters" do
+      type.newparam(:param) {}
+      instance = type.new(:name => 'test')
+
+      expect { instance[:param] = true }.to_not raise_error
+      expect { instance["param"] = true }.to_not raise_error
+      instance[:param].should == true
+      instance["param"].should == true
+    end
+
+    it "should work with meta-parameters" do
+      instance = type.new(:name => 'test')
+
+      expect { instance[:noop] = true }.to_not raise_error
+      expect { instance["noop"] = true }.to_not raise_error
+      instance[:noop].should == true
+      instance["noop"].should == true
+    end
+
+    it "should work with properties" do
+      type.newproperty(:property) {}
+      instance = type.new(:name => 'test')
+
+      expect { instance[:property] = true }.to_not raise_error
+      expect { instance["property"] = true }.to_not raise_error
+      instance.property(:property).must be
+      instance.should(:property).must be_true
+    end
+
+    it "should handle proprieties correctly" do
+      # Order of assignment is significant in this test.
+      props = {}
+      [:one, :two, :three].each {|prop| type.newproperty(prop) {} }
+      instance = type.new(:name => "test")
+
+      instance[:one] = "boo"
+      one = instance.property(:one)
+      instance.properties.must == [one]
+
+      instance[:three] = "rah"
+      three = instance.property(:three)
+      instance.properties.must == [one, three]
+
+      instance[:two] = "whee"
+      two = instance.property(:two)
+      instance.properties.must == [one, two, three]
+    end
+
+    it "newattr should handle required features correctly" do
+      Puppet::Util::Log.level = :debug
+
+      type.feature :feature1, "one"
+      type.feature :feature2, "two"
+
+      none = type.newproperty(:none) {}
+      one  = type.newproperty(:one, :required_features => :feature1) {}
+      two  = type.newproperty(:two, :required_features => [:feature1, :feature2]) {}
+
+      nope  = type.provide(:nope)  {}
+      maybe = type.provide(:maybe) { has_features :feature1 }
+      yep   = type.provide(:yep)   { has_features :feature1, :feature2 }
+
+      [nope, maybe, yep].each_with_index do |provider, i|
+        rsrc = type.new(:provider => provider.name, :name => "test#{i}",
+                        :none => "a", :one => "b", :two => "c")
+
+        rsrc.should(:none).must be
+
+        if provider.declared_feature? :feature1
+          rsrc.should(:one).must be
+        else
+          rsrc.should(:one).must_not be
+          @logs.find {|l| l.message =~ /not managing attribute one/ }.should be
+        end
+
+        if provider.declared_feature? :feature2
+          rsrc.should(:two).must be
+        else
+          rsrc.should(:two).must_not be
+          @logs.find {|l| l.message =~ /not managing attribute two/ }.should be
+        end
+      end
+    end
+  end
 end

data/spec/unit/util/adsi_spec.rb

@@ -28,21 +28,25 @@ describe Puppet::Util::ADSI do
     Puppet::Util::ADSI.computer_uri.should == "WinNT://testcomputername"
   end
 
-  describe ".sid_for_account", :if => Puppet.features.microsoft_windows? do
+  describe ".sid_for_account" do
     it "should return nil if the account does not exist" do
-      Puppet::Util::Windows::Security.expects(:name_to_sid).with('foobar').returns nil
+      connection.expects(:execquery).returns([])
 
       Puppet::Util::ADSI.sid_for_account('foobar').should be_nil
     end
 
     it "should return a SID for a passed user or group name" do
-      Puppet::Util::Windows::Security.expects(:name_to_sid).with('testers').returns 'S-1-5-32-547'
+      Puppet::Util::ADSI.expects(:execquery).with(
+        "SELECT Sid from Win32_Account WHERE Name = 'testers' AND LocalAccount = true"
+      ).returns([stub('acct_id', :Sid => 'S-1-5-32-547')])
 
       Puppet::Util::ADSI.sid_for_account('testers').should == 'S-1-5-32-547'
     end
 
     it "should return a SID for a passed fully-qualified user or group name" do
-      Puppet::Util::Windows::Security.expects(:name_to_sid).with('MACHINE\testers').returns 'S-1-5-32-547'
+      Puppet::Util::ADSI.expects(:execquery).with(
+        "SELECT Sid from Win32_Account WHERE Name = 'testers' AND Domain = 'MACHINE' AND LocalAccount = true"
+      ).returns([stub('acct_id', :Sid => 'S-1-5-32-547')])
 
       Puppet::Util::ADSI.sid_for_account('MACHINE\testers').should == 'S-1-5-32-547'
     end
@@ -225,23 +229,4 @@ describe Puppet::Util::ADSI do
       Puppet::Util::ADSI::Group.delete(groupname)
     end
   end
-
-  describe Puppet::Util::ADSI::UserProfile do
-    it "should be able to delete a user profile" do
-      connection.expects(:Delete).with("Win32_UserProfile.SID='S-A-B-C'")
-      Puppet::Util::ADSI::UserProfile.delete('S-A-B-C')
-    end
-
-    it "should warn on 2003" do
-      connection.expects(:Delete).raises(RuntimeError,
- "Delete (WIN32OLERuntimeError)
-    OLE error code:80041010 in SWbemServicesEx
-      Invalid class
-    HRESULT error code:0x80020009
-      Exception occurred.")
-
-      Puppet.expects(:warning).with("Cannot delete user profile for 'S-A-B-C' prior to Vista SP1")
-      Puppet::Util::ADSI::UserProfile.delete('S-A-B-C')
-    end
-  end
 end

data/spec/unit/util/autoload_spec.rb

@@ -1,43 +1,47 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/util/autoload'
 
 describe Puppet::Util::Autoload do
   include PuppetSpec::Files
-
   before do
     @autoload = Puppet::Util::Autoload.new("foo", "tmp")
 
-    @autoload.stubs(:eachdir).yields "/my/dir"
+    @autoload.stubs(:eachdir).yields make_absolute("/my/dir")
+    @loaded = {}
+    @autoload.class.stubs(:loaded).returns(@loaded)
   end
 
   describe "when building the search path" do
     before :each do
-      @dira = make_absolute('/a')
-      @dirb = make_absolute('/b')
-      @dirc = make_absolute('/c')
+      ## modulepath/libdir can't be used until after app settings are initialized, so we need to simulate that:
+      Puppet.settings.expects(:app_defaults_initialized?).returns(true).at_least_once
+
+      @dira = File.expand_path('/a')
+      @dirb = File.expand_path('/b')
+      @dirc = File.expand_path('/c')
     end
 
-    it "should collect all of the plugins and lib directories that exist in the current environment's module path" do
-      Puppet.settings.expects(:value).with(:environment).returns "foo"
-      Puppet.settings.expects(:value).with(:modulepath, :foo).returns "#{@dira}#{File::PATH_SEPARATOR}#{@dirb}#{File::PATH_SEPARATOR}#{@dirc}"
+    it "should collect all of the lib directories that exist in the current environment's module path" do
+      Puppet[:environment] = "foo"
+      Puppet.settings.set_value(:modulepath, "#{@dira}#{File::PATH_SEPARATOR}#{@dirb}#{File::PATH_SEPARATOR}#{@dirc}", :foo)
       Dir.expects(:entries).with(@dira).returns %w{one two}
       Dir.expects(:entries).with(@dirb).returns %w{one two}
 
       FileTest.stubs(:directory?).returns false
       FileTest.expects(:directory?).with(@dira).returns true
       FileTest.expects(:directory?).with(@dirb).returns true
-      ["#{@dira}/one/plugins", "#{@dira}/two/lib", "#{@dirb}/one/plugins", "#{@dirb}/two/lib"].each do |d|
+      ["#{@dira}/two/lib", "#{@dirb}/two/lib"].each do |d|
         FileTest.expects(:directory?).with(d).returns true
       end
 
-      @autoload.module_directories.should == ["#{@dira}/one/plugins", "#{@dira}/two/lib", "#{@dirb}/one/plugins", "#{@dirb}/two/lib"]
+      @autoload.class.module_directories.should == ["#{@dira}/two/lib", "#{@dirb}/two/lib"]
     end
 
     it "should not look for lib directories in directories starting with '.'" do
-      Puppet.settings.expects(:value).with(:environment).returns "foo"
-      Puppet.settings.expects(:value).with(:modulepath, :foo).returns @dira
+      Puppet[:environment] = "foo"
+      Puppet.settings.set_value(:modulepath, @dira, :foo)
       Dir.expects(:entries).with(@dira).returns %w{. ..}
 
       FileTest.expects(:directory?).with(@dira).returns true
@@ -46,37 +50,28 @@ describe Puppet::Util::Autoload do
       FileTest.expects(:directory?).with("#{@dira}/../lib").never
       FileTest.expects(:directory?).with("#{@dira}/../plugins").never
 
-      @autoload.module_directories
+      @autoload.class.module_directories
     end
 
     it "should include the module directories, the Puppet libdir, and all of the Ruby load directories" do
-      Puppet.stubs(:[]).with(:libdir).returns(%w{/libdir1 /lib/dir/two /third/lib/dir}.join(File::PATH_SEPARATOR))
-      @autoload.expects(:module_directories).returns %w{/one /two}
-      @autoload.search_directories.should == %w{/one /two /libdir1 /lib/dir/two /third/lib/dir} + $LOAD_PATH
-    end
-
-    it "should include in its search path all of the unique search directories that have a subdirectory matching the autoload path" do
-      @autoload = Puppet::Util::Autoload.new("foo", "loaddir")
-      @autoload.expects(:search_directories).returns %w{/one /two /three /three}
-      FileTest.expects(:directory?).with("/one/loaddir").returns true
-      FileTest.expects(:directory?).with("/two/loaddir").returns false
-      FileTest.expects(:directory?).with("/three/loaddir").returns true
-      @autoload.searchpath.should == ["/one/loaddir", "/three/loaddir"]
+      Puppet[:libdir] = %w{/libdir1 /lib/dir/two /third/lib/dir}.join(File::PATH_SEPARATOR)
+      @autoload.class.expects(:gem_directories).returns %w{/one /two}
+      @autoload.class.expects(:module_directories).returns %w{/three /four}
+      @autoload.class.search_directories.should == %w{/one /two /three /four} + Puppet[:libdir].split(File::PATH_SEPARATOR) + $LOAD_PATH
     end
   end
 
-  it "should include its FileCache module" do
-    Puppet::Util::Autoload.ancestors.should be_include(Puppet::Util::Autoload::FileCache)
-  end
-
   describe "when loading a file" do
     before do
-      @autoload.stubs(:searchpath).returns %w{/a}
+      @autoload.class.stubs(:search_directories).returns [make_absolute("/a")]
+      FileTest.stubs(:directory?).returns true
+      @time_a = Time.utc(2010, 'jan', 1, 6, 30)
+      File.stubs(:mtime).returns @time_a
     end
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
       it "should die with Puppet::Error if a #{error.to_s} exception is thrown" do
-        @autoload.stubs(:file_exist?).returns true
+        File.stubs(:exist?).returns true
 
         Kernel.expects(:load).raises error
 
@@ -88,42 +83,183 @@ describe Puppet::Util::Autoload do
       @autoload.load("foo").should == false
     end
 
+    it "should register loaded files with the autoloader" do
+      File.stubs(:exist?).returns true
+      Kernel.stubs(:load)
+      @autoload.load("myfile")
+
+      @autoload.class.loaded?("tmp/myfile.rb").should be
+
+      $LOADED_FEATURES.delete("tmp/myfile.rb")
+    end
+
+    it "should be seen by loaded? on the instance using the short name" do
+      File.stubs(:exist?).returns true
+      Kernel.stubs(:load)
+      @autoload.load("myfile")
+
+      @autoload.loaded?("myfile.rb").should be
+
+      $LOADED_FEATURES.delete("tmp/myfile.rb")
+    end
+
     it "should register loaded files with the main loaded file list so they are not reloaded by ruby" do
-      @autoload.stubs(:file_exist?).returns true
+      File.stubs(:exist?).returns true
       Kernel.stubs(:load)
 
       @autoload.load("myfile")
 
       $LOADED_FEATURES.should be_include("tmp/myfile.rb")
+
+      $LOADED_FEATURES.delete("tmp/myfile.rb")
+    end
+
+    it "should load the first file in the searchpath" do
+      @autoload.stubs(:search_directories).returns [make_absolute("/a"), make_absolute("/b")]
+      FileTest.stubs(:directory?).returns true
+      File.stubs(:exist?).returns true
+      Kernel.expects(:load).with(make_absolute("/a/tmp/myfile.rb"), optionally(anything))
+
+      @autoload.load("myfile")
+
+      $LOADED_FEATURES.delete("tmp/myfile.rb")
+    end
+
+    it "should treat equivalent paths to a loaded file as loaded" do
+      File.stubs(:exist?).returns true
+      Kernel.stubs(:load)
+      @autoload.load("myfile")
+
+      @autoload.class.loaded?("tmp/myfile").should be
+      @autoload.class.loaded?("tmp/./myfile.rb").should be
+      @autoload.class.loaded?("./tmp/myfile.rb").should be
+      @autoload.class.loaded?("tmp/../tmp/myfile.rb").should be
+
+      $LOADED_FEATURES.delete("tmp/myfile.rb")
     end
   end
 
   describe "when loading all files" do
     before do
-      @autoload.stubs(:searchpath).returns %w{/a}
-      @filename = rand(10000).to_s + ".rb"
-      Dir.stubs(:glob).returns(@filename)
+      @autoload.class.stubs(:search_directories).returns [make_absolute("/a")]
+      FileTest.stubs(:directory?).returns true
+      Dir.stubs(:glob).returns [make_absolute("/a/foo/file.rb")]
+      File.stubs(:exist?).returns true
+      @time_a = Time.utc(2010, 'jan', 1, 6, 30)
+      File.stubs(:mtime).returns @time_a
+
+      @autoload.class.stubs(:loaded?).returns(false)
     end
 
     [RuntimeError, LoadError, SyntaxError].each do |error|
-      it "dies if a #{error.to_s} exception is thrown", :'fails_on_ruby_1.9.2' => true do
-        Kernel.expects(:require).raises error
+      it "should die an if a #{error.to_s} exception is thrown" do
+        Kernel.expects(:load).raises error
 
-        expect { @autoload.loadall }.to raise_error(Puppet::Error)
+        lambda { @autoload.loadall }.should raise_error(Puppet::Error)
       end
     end
 
-    it "requires the file", :'fails_on_ruby_1.9.2' => true do
-      Kernel.expects(:require).with(@filename)
+    it "should require the full path to the file" do
+      Kernel.expects(:load).with(make_absolute("/a/foo/file.rb"), optionally(anything))
 
       @autoload.loadall
     end
+  end
+
+  describe "when reloading files" do
+    before :each do
+      @file_a = make_absolute("/a/file.rb")
+      @file_b = make_absolute("/b/file.rb")
+      @first_time = Time.utc(2010, 'jan', 1, 6, 30)
+      @second_time = @first_time + 60
+    end
+
+    after :each do
+      $LOADED_FEATURES.delete("a/file.rb")
+      $LOADED_FEATURES.delete("b/file.rb")
+    end
+
+    it "#changed? should return true for a file that was not loaded" do
+      @autoload.class.changed?(@file_a).should be
+    end
+
+    it "changes should be seen by changed? on the instance using the short name" do
+      File.stubs(:mtime).returns(@first_time)
+      File.stubs(:exist?).returns true
+      Kernel.stubs(:load)
+      @autoload.load("myfile")
+      @autoload.loaded?("myfile").should be
+      @autoload.changed?("myfile").should_not be
+
+      File.stubs(:mtime).returns(@second_time)
+      @autoload.changed?("myfile").should be
+
+      $LOADED_FEATURES.delete("tmp/myfile.rb")
+    end
+
+    describe "in one directory" do
+      before :each do
+        @autoload.class.stubs(:search_directories).returns [make_absolute("/a")]
+        File.expects(:mtime).with(@file_a).returns(@first_time)
+        @autoload.class.mark_loaded("file", @file_a)
+      end
 
-    it "marks the file as required even if loading fails", :'fails_on_ruby_1.9.2' => true do
-      Dir.stubs(:glob).returns "/this/file/does/not/exist.rb"
+      it "should reload if mtime changes" do
+        File.stubs(:mtime).with(@file_a).returns(@first_time + 60)
+        File.stubs(:exist?).with(@file_a).returns true
+        Kernel.expects(:load).with(@file_a, optionally(anything))
+        @autoload.class.reload_changed
+      end
+
+      it "should do nothing if the file is deleted" do
+        File.stubs(:mtime).with(@file_a).raises(Errno::ENOENT)
+        File.stubs(:exist?).with(@file_a).returns false
+        Kernel.expects(:load).never
+        @autoload.class.reload_changed
+      end
+    end
+
+    describe "in two directories" do
+      before :each do
+        @autoload.class.stubs(:search_directories).returns [make_absolute("/a"), make_absolute("/b")]
+      end
+
+      it "should load b/file when a/file is deleted" do
+        File.expects(:mtime).with(@file_a).returns(@first_time)
+        @autoload.class.mark_loaded("file", @file_a)
+        File.stubs(:mtime).with(@file_a).raises(Errno::ENOENT)
+        File.stubs(:exist?).with(@file_a).returns false
+        File.stubs(:exist?).with(@file_b).returns true
+        File.stubs(:mtime).with(@file_b).returns @first_time
+        Kernel.expects(:load).with(@file_b, optionally(anything))
+        @autoload.class.reload_changed
+        @autoload.class.send(:loaded)["file"].should == [@file_b, @first_time]
+      end
 
-      expect { @autoload.loadall }.to raise_error(Puppet::Error)
-      expect { @autoload.loadall }.not_to raise_error
+      it "should load a/file when b/file is loaded and a/file is created" do
+        File.stubs(:mtime).with(@file_b).returns @first_time
+        File.stubs(:exist?).with(@file_b).returns true
+        @autoload.class.mark_loaded("file", @file_b)
+
+        File.stubs(:mtime).with(@file_a).returns @first_time
+        File.stubs(:exist?).with(@file_a).returns true
+        Kernel.expects(:load).with(@file_a, optionally(anything))
+        @autoload.class.reload_changed
+        @autoload.class.send(:loaded)["file"].should == [@file_a, @first_time]
+      end
+    end
+  end
+
+  describe "#cleanpath" do
+    it "should leave relative paths relative" do
+      path = "hello/there"
+      Puppet::Util::Autoload.cleanpath(path).should == path
+    end
+
+    describe "on Windows", :if => Puppet.features.microsoft_windows? do
+      it "should convert c:\ to c:/" do
+        Puppet::Util::Autoload.cleanpath('c:\\').should == 'c:/'
+      end
     end
   end
 end