puppet 2.7.3 → 2.7.4

data/spec/unit/type/group_spec.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe Puppet::Type.type(:group) do
+describe Puppet::Type.type(:group), :fails_on_windows => true do
   before do
     ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin" unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
     @class = Puppet::Type.type(:group)

data/spec/unit/type/mount_spec.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe Puppet::Type.type(:mount) do
+describe Puppet::Type.type(:mount), :fails_on_windows => true do
   it "should have a :refreshable feature that requires the :remount method" do
     Puppet::Type.type(:mount).provider_feature(:refreshable).methods.should == [:remount]
   end
@@ -16,7 +16,7 @@ describe Puppet::Type.type(:mount) do
   end
 end
 
-describe Puppet::Type.type(:mount), "when validating attributes" do
+describe Puppet::Type.type(:mount), "when validating attributes", :fails_on_windows => true do
   [:name, :remounts, :provider].each do |param|
     it "should have a #{param} parameter" do
       Puppet::Type.type(:mount).attrtype(param).should == :param
@@ -30,7 +30,7 @@ describe Puppet::Type.type(:mount), "when validating attributes" do
   end
 end
 
-describe Puppet::Type.type(:mount)::Ensure, "when validating values" do
+describe Puppet::Type.type(:mount)::Ensure, "when validating values", :fails_on_windows => true do
   before do
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil
     Puppet::Type.type(:mount).defaultprovider.expects(:new).returns(@provider)
@@ -62,7 +62,7 @@ describe Puppet::Type.type(:mount)::Ensure, "when validating values" do
   end
 end
 
-describe Puppet::Type.type(:mount)::Ensure do
+describe Puppet::Type.type(:mount)::Ensure, :fails_on_windows => true do
   before :each do
     provider_properties = {}
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :property_hash => provider_properties
@@ -279,7 +279,7 @@ describe Puppet::Type.type(:mount)::Ensure do
   end
 end
 
-describe Puppet::Type.type(:mount), "when modifying an existing mount entry" do
+describe Puppet::Type.type(:mount), "when modifying an existing mount entry", :fails_on_windows => true do
   before do
     @provider = stub 'provider', :class => Puppet::Type.type(:mount).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock, :remount => nil
     Puppet::Type.type(:mount).defaultprovider.stubs(:new).returns(@provider)

data/spec/unit/type/noop_metaparam_spec.rb

@@ -4,9 +4,11 @@ require 'spec_helper'
 require 'puppet/type'
 
 describe Puppet::Type.type(:file).attrclass(:noop) do
+  include PuppetSpec::Files
+
   before do
     Puppet.settings.stubs(:use)
-    @file = Puppet::Type.newfile :path => "/what/ever"
+    @file = Puppet::Type.newfile :path => make_absolute("/what/ever")
   end
 
   it "should accept true as a value" do

data/spec/unit/type/package_spec.rb

@@ -27,7 +27,7 @@ describe Puppet::Type.type(:package) do
   end
 
   it "should default to being installed" do
-    pkg = Puppet::Type.type(:package).new(:name => "yay")
+    pkg = Puppet::Type.type(:package).new(:name => "yay", :provider => :apt)
     pkg.should(:ensure).should == :present
   end
 
@@ -45,7 +45,12 @@ describe Puppet::Type.type(:package) do
 
   describe "when validating attribute values" do
     before do
-      @provider = stub 'provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil
+      @provider = stub(
+        'provider',
+        :class           => Puppet::Type.type(:package).defaultprovider,
+        :clear           => nil,
+        :validate_source => nil
+      )
       Puppet::Type.type(:package).defaultprovider.expects(:new).returns(@provider)
     end
 
@@ -105,7 +110,14 @@ describe Puppet::Type.type(:package) do
 
   describe Puppet::Type.type(:package) do
     before :each do
-      @provider = stub 'provider', :class => Puppet::Type.type(:package).defaultprovider, :clear => nil, :satisfies? => true, :name => :mock
+      @provider = stub(
+        'provider',
+        :class           => Puppet::Type.type(:package).defaultprovider,
+        :clear           => nil,
+        :satisfies?      => true,
+        :name            => :mock,
+        :validate_source => nil
+      )
       Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(@provider)
       Puppet::Type.type(:package).defaultprovider.stubs(:instances).returns([])
       @package = Puppet::Type.type(:package).new(:name => "yay")

data/spec/unit/type/resources_spec.rb

@@ -51,7 +51,7 @@ describe resources do
           @resources.generate.collect { |r| r.ref }.should_not include(@host1.ref)
         end
 
-        it "should not include the skipped users", :'fails_on_ruby_1.9.2' => true do
+        it "should not include the skipped users", :'fails_on_ruby_1.9.2' => true, :fails_on_windows => true do
           res = Puppet::Type.type(:resources).new :name => :user, :purge => true
           res.catalog = Puppet::Resource::Catalog.new
 
@@ -72,7 +72,7 @@ describe resources do
           end
         end
 
-        describe "when the instance's do not have an ensure property" do
+        describe "when the instance's do not have an ensure property", :fails_on_windows => true do
           it "should not be included in the generated resources" do
             @no_ensure_resource = Puppet::Type.type(:exec).new(:name => '/usr/bin/env echo')
             Puppet::Type.type(:host).stubs(:instances).returns [@no_ensure_resource]

data/spec/unit/type/service_spec.rb

@@ -57,6 +57,21 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
     Puppet::Type.type(:service).new(:name => "yay", :enable => :false)
   end
 
+  it "should support :manual as a value to :enable on Windows" do
+    Puppet.features.stubs(:microsoft_windows?).returns true
+
+    Puppet::Type.type(:service).new(:name => "yay", :enable => :manual)
+  end
+
+  it "should not support :manual as a value to :enable when not on Windows" do
+    Puppet.features.stubs(:microsoft_windows?).returns false
+
+    expect { Puppet::Type.type(:service).new(:name => "yay", :enable => :manual) }.to raise_error(
+      Puppet::Error,
+      /Setting enable to manual is only supported on Microsoft Windows\./
+    )
+  end
+
   it "should support :true as a value to :hasstatus" do
     Puppet::Type.type(:service).new(:name => "yay", :hasstatus => :true)
   end
@@ -91,17 +106,17 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
     svc.should(:enable).should be_nil
   end
 
-  it "should split paths on ':'" do
+  it "should split paths on '#{File::PATH_SEPARATOR}'" do
     FileTest.stubs(:exist?).returns(true)
     FileTest.stubs(:directory?).returns(true)
-    svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two:/three/four")
+    svc = Puppet::Type.type(:service).new(:name => "yay", :path => "/one/two#{File::PATH_SEPARATOR}/three/four")
     svc[:path].should == %w{/one/two /three/four}
   end
 
-  it "should accept arrays of paths joined by ':'" do
+  it "should accept arrays of paths joined by '#{File::PATH_SEPARATOR}'" do
     FileTest.stubs(:exist?).returns(true)
     FileTest.stubs(:directory?).returns(true)
-    svc = Puppet::Type.type(:service).new(:name => "yay", :path => ["/one:/two", "/three:/four"])
+    svc = Puppet::Type.type(:service).new(:name => "yay", :path => ["/one#{File::PATH_SEPARATOR}/two", "/three#{File::PATH_SEPARATOR}/four"])
     svc[:path].should == %w{/one /two /three /four}
   end
 end

data/spec/unit/type/ssh_authorized_key_spec.rb

@@ -3,7 +3,9 @@ require 'spec_helper'
 
 ssh_authorized_key = Puppet::Type.type(:ssh_authorized_key)
 
-describe ssh_authorized_key do
+describe ssh_authorized_key, :unless => Puppet.features.microsoft_windows? do
+  include PuppetSpec::Files
+
   before do
     @class = Puppet::Type.type(:ssh_authorized_key)
 
@@ -11,7 +13,7 @@ describe ssh_authorized_key do
     @class.stubs(:defaultprovider).returns(@provider_class)
     @class.stubs(:provider).returns(@provider_class)
 
-    @provider = stub 'provider', :class => @provider_class, :file_path => "/tmp/whatever", :clear => nil
+    @provider = stub 'provider', :class => @provider_class, :file_path => make_absolute("/tmp/whatever"), :clear => nil
     @provider_class.stubs(:new).returns(@provider)
     @catalog = Puppet::Resource::Catalog.new
   end
@@ -134,6 +136,10 @@ describe ssh_authorized_key do
         proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'command="command"')}.should_not raise_error
       end
 
+      it "should support key-value pairs where value consist of multiple items" do
+        proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'from="*.domain1,host1.domain2"')}.should_not raise_error
+      end
+
       it "should support environments as options" do
         proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'environment="NAME=value"')}.should_not raise_error
       end
@@ -142,7 +148,7 @@ describe ssh_authorized_key do
         proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ['cert-authority','environment="NAME=value"'])}.should_not raise_error
       end
 
-      it "should not support a comma separated lists" do
+      it "should not support a comma separated list" do
         proc { @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => 'cert-authority,no-port-forwarding')}.should raise_error(Puppet::Error, /must be provided as an array/)
       end
 
@@ -155,7 +161,7 @@ describe ssh_authorized_key do
         resource.property(:options).is_to_s(["a","b","c"]).should == "a,b,c"
       end
 
-      it "property should return well formed string of arrays from is_to_s" do
+      it "property should return well formed string of arrays from should_to_s" do
         resource = @class.new(:name => "whev", :type => :rsa, :user => "nobody", :options => ["a","b","c"])
         resource.property(:options).should_to_s(["a","b","c"]).should == "a,b,c"
       end

data/spec/unit/type/tidy_spec.rb

@@ -5,8 +5,10 @@ require 'puppet/file_bucket/dipper'
 tidy = Puppet::Type.type(:tidy)
 
 describe tidy do
+  include PuppetSpec::Files
+
   before do
-    @basepath = Puppet.features.posix? ? "/what/ever" : "C:/tmp"
+    @basepath = make_absolute("/what/ever")
     Puppet.settings.stubs(:use)
 
     # for an unknown reason some of these specs fails when run individually

data/spec/unit/type/user_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 user = Puppet::Type.type(:user)
 
-describe user do
+describe user, :fails_on_windows => true do
   before do
     ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin" unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
     @provider = stub 'provider'

data/spec/unit/type_spec.rb

@@ -1,10 +1,8 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
 
-describe Puppet::Type do
-  it "should include the Cacher module" do
-    Puppet::Type.ancestors.should be_include(Puppet::Util::Cacher)
-  end
+describe Puppet::Type, :fails_on_windows => true do
+  include PuppetSpec::Files
 
   it "should consider a parameter to be valid if it is a valid parameter" do
     Puppet::Type.type(:mount).should be_valid_parameter(:path)
@@ -18,18 +16,6 @@ describe Puppet::Type do
     Puppet::Type.type(:mount).should be_valid_parameter(:noop)
   end
 
-  it "should use its catalog as its expirer" do
-    catalog = Puppet::Resource::Catalog.new
-    resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
-    resource.catalog = catalog
-    resource.expirer.should equal(catalog)
-  end
-
-  it "should do nothing when asked to expire when it has no catalog" do
-    resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
-    lambda { resource.expire }.should_not raise_error
-  end
-
   it "should be able to retrieve a property by name" do
     resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present)
     resource.property(:fstype).must be_instance_of(Puppet::Type.type(:mount).attrclass(:fstype))
@@ -309,7 +295,8 @@ describe Puppet::Type do
       end
 
       it "should use the Resource Type's namevar to determine how to find the name in the hash" do
-        Puppet::Type.type(:file).new(:path => "/yay").title.should == "/yay"
+        yay = make_absolute('/yay')
+        Puppet::Type.type(:file).new(:path => yay).title.should == yay
       end
 
       [:catalog].each do |param|
@@ -373,11 +360,11 @@ describe Puppet::Type do
     end
 
     # This one is really hard to test :/
-    it "should each default immediately if no value is provided" do
+    it "should set each default immediately if no value is provided" do
       defaults = []
-      Puppet::Type.type(:package).any_instance.stubs(:set_default).with { |value| defaults << value; true }
+      Puppet::Type.type(:service).any_instance.stubs(:set_default).with { |value| defaults << value; true }
 
-      Puppet::Type.type(:package).new :name => "whatever"
+      Puppet::Type.type(:service).new :name => "whatever"
 
       defaults[0].should == :provider
     end
@@ -387,7 +374,7 @@ describe Puppet::Type do
     end
 
     it "should delete the name via the namevar from the originally provided parameters" do
-      Puppet::Type.type(:file).new(:name => "/foo").original_parameters[:path].should be_nil
+      Puppet::Type.type(:file).new(:name => make_absolute('/foo')).original_parameters[:path].should be_nil
     end
   end
 
@@ -471,7 +458,7 @@ describe Puppet::Type do
     end
 
     it "should provide a value for 'ensure' even if no desired value is provided" do
-      @resource = Puppet::Type.type(:file).new(:path => "/my/file/that/can't/exist")
+      @resource = Puppet::Type.type(:file).new(:path => make_absolute("/my/file/that/can't/exist"))
     end
 
     it "should not call retrieve on non-ensure properties if the resource is absent and should consider the property absent" do
@@ -513,8 +500,8 @@ describe Puppet::Type do
     before do
       @catalog = Puppet::Resource::Catalog.new
       @container = Puppet::Type.type(:component).new(:name => "container")
-      @one = Puppet::Type.type(:file).new(:path => "/file/one")
-      @two = Puppet::Type.type(:file).new(:path => "/file/two")
+      @one = Puppet::Type.type(:file).new(:path => make_absolute("/file/one"))
+      @two = Puppet::Type.type(:file).new(:path => make_absolute("/file/two"))
 
       @catalog.add_resource @container
       @catalog.add_resource @one
@@ -541,7 +528,9 @@ describe Puppet::Type do
   end
 end
 
-describe Puppet::Type::RelationshipMetaparam do
+describe Puppet::Type::RelationshipMetaparam, :fails_on_windows => true do
+  include PuppetSpec::Files
+
   it "should be a subclass of Puppet::Parameter" do
     Puppet::Type::RelationshipMetaparam.superclass.should equal(Puppet::Parameter)
   end
@@ -550,14 +539,15 @@ describe Puppet::Type::RelationshipMetaparam do
     Puppet::Type::RelationshipMetaparam.should respond_to(:subclasses)
   end
 
-  describe "when munging relationships" do
+  describe "when munging relationships", :'fails_on_windows' => true do
     before do
-      @resource = Puppet::Type.type(:mount).new :name => "/foo"
+      @path = make_absolute('/foo')
+      @resource = Puppet::Type.type(:mount).new :name => @path
       @metaparam = Puppet::Type.metaparamclass(:require).new :resource => @resource
     end
 
     it "should accept Puppet::Resource instances" do
-      ref = Puppet::Resource.new(:file, "/foo")
+      ref = Puppet::Resource.new(:file, @path)
       @metaparam.munge(ref)[0].should equal(ref)
     end
 
@@ -585,18 +575,22 @@ describe Puppet::Type::RelationshipMetaparam do
   end
 end
 
-describe Puppet::Type.metaparamclass(:check) do
+describe Puppet::Type.metaparamclass(:check), :fails_on_windows => true do
+  include PuppetSpec::Files
+
   it "should warn and create an instance of ':audit'" do
-    file = Puppet::Type.type(:file).new :path => "/foo"
+    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
+describe Puppet::Type.metaparamclass(:audit), :fails_on_windows => true do
+  include PuppetSpec::Files
+
   before do
-    @resource = Puppet::Type.type(:file).new :path => "/foo"
+    @resource = Puppet::Type.type(:file).new :path => make_absolute('/foo')
   end
 
   it "should default to being nil" do
@@ -642,8 +636,9 @@ describe Puppet::Type.metaparamclass(:audit) do
       Puppet::Type.type(:file).stubs(:title_patterns).returns(
         [ [ /(.*)/, [ [:path, lambda{|x| x} ] ] ] ]
       )
-      res = Puppet::Type.type(:file).new( :title => '/my/file', :path => '/my/file', :owner => 'root', :content => 'hello' )
-      res.uniqueness_key.should == [ nil, 'root', '/my/file']
+      myfile = make_absolute('/my/file')
+      res = Puppet::Type.type(:file).new( :title => myfile, :path => myfile, :owner => 'root', :content => 'hello' )
+      res.uniqueness_key.should == [ nil, 'root', myfile]
     end
   end
 end

data/spec/unit/util/adsi_spec.rb

@@ -0,0 +1,202 @@
+#!/usr/bin/env ruby
+
+require 'spec_helper'
+
+require 'puppet/util/adsi'
+
+describe Puppet::Util::ADSI do
+  let(:connection) { stub 'connection' }
+
+  before(:each) do
+    Puppet::Util::ADSI.instance_variable_set(:@computer_name, 'testcomputername')
+    Puppet::Util::ADSI.stubs(:connect).returns connection
+  end
+
+  it "should generate the correct URI for a resource" do
+    Puppet::Util::ADSI.uri('test', 'user').should == "WinNT://testcomputername/test,user"
+  end
+
+  it "should be able to get the name of the computer" do
+    Puppet::Util::ADSI.computer_name.should == 'testcomputername'
+  end
+
+  it "should be able to provide the correct WinNT base URI for the computer" do
+    Puppet::Util::ADSI.computer_uri.should == "WinNT://testcomputername"
+  end
+
+  describe Puppet::Util::ADSI::User do
+    let(:username)  { 'testuser' }
+
+    it "should generate the correct URI" do
+      Puppet::Util::ADSI::User.uri(username).should == "WinNT://testcomputername/#{username},user"
+    end
+
+    it "should be able to create a user" do
+      adsi_user = stub('adsi')
+
+      connection.expects(:Create).with('user', username).returns(adsi_user)
+
+      user = Puppet::Util::ADSI::User.create(username)
+
+      user.should be_a(Puppet::Util::ADSI::User)
+      user.native_user.should == adsi_user
+    end
+
+    it "should be able to check the existence of a user" do
+      Puppet::Util::ADSI.expects(:connect).with("WinNT://testcomputername/#{username},user").returns connection
+      Puppet::Util::ADSI::User.exists?(username).should be_true
+    end
+
+    it "should be able to delete a user" do
+      connection.expects(:Delete).with('user', username)
+
+      Puppet::Util::ADSI::User.delete(username)
+    end
+
+    describe "an instance" do
+      let(:adsi_user) { stub 'user' }
+      let(:user)      { Puppet::Util::ADSI::User.new(username, adsi_user) }
+
+      it "should provide its groups as a list of names" do
+        names = ["group1", "group2"]
+
+        groups = names.map { |name| mock('group', :Name => name) }
+
+        adsi_user.expects(:Groups).returns(groups)
+
+        user.groups.should =~ names
+      end
+
+      it "should be able to test whether a given password is correct" do
+        Puppet::Util::ADSI::User.expects(:logon).with(username, 'pwdwrong').returns(false)
+        Puppet::Util::ADSI::User.expects(:logon).with(username, 'pwdright').returns(true)
+
+        user.password_is?('pwdwrong').should be_false
+        user.password_is?('pwdright').should be_true
+      end
+
+      it "should be able to set a password" do
+        adsi_user.expects(:SetPassword).with('pwd')
+        adsi_user.expects(:SetInfo).at_least_once
+
+        flagname = "UserFlags"
+        fADS_UF_DONT_EXPIRE_PASSWD = 0x10000
+
+        adsi_user.expects(:Get).with(flagname).returns(0)
+        adsi_user.expects(:Put).with(flagname, fADS_UF_DONT_EXPIRE_PASSWD)
+
+        user.password = 'pwd'
+      end
+
+      it "should generate the correct URI" do
+        user.uri.should == "WinNT://testcomputername/#{username},user"
+      end
+
+      describe "when given a set of groups to which to add the user" do
+        let(:groups_to_set) { 'group1,group2' }
+
+        before(:each) do
+          user.expects(:groups).returns ['group2', 'group3']
+        end
+
+        describe "if membership is specified as inclusive" do
+          it "should add the user to those groups, and remove it from groups not in the list" do
+            group1 = stub 'group1'
+            group1.expects(:Add).with("WinNT://testcomputername/#{username},user")
+
+            group3 = stub 'group1'
+            group3.expects(:Remove).with("WinNT://testcomputername/#{username},user")
+
+            Puppet::Util::ADSI.expects(:connect).with('WinNT://testcomputername/group1,group').returns group1
+            Puppet::Util::ADSI.expects(:connect).with('WinNT://testcomputername/group3,group').returns group3
+
+            user.set_groups(groups_to_set, false)
+          end
+        end
+
+        describe "if membership is specified as minimum" do
+          it "should add the user to the specified groups without affecting its other memberships" do
+            group1 = stub 'group1'
+            group1.expects(:Add).with("WinNT://testcomputername/#{username},user")
+
+            Puppet::Util::ADSI.expects(:connect).with('WinNT://testcomputername/group1,group').returns group1
+
+            user.set_groups(groups_to_set, true)
+          end
+        end
+      end
+    end
+  end
+
+  describe Puppet::Util::ADSI::Group do
+    let(:groupname)  { 'testgroup' }
+
+    describe "an instance" do
+      let(:adsi_group) { stub 'group' }
+      let(:group)      { Puppet::Util::ADSI::Group.new(groupname, adsi_group) }
+
+      it "should be able to add a member" do
+        adsi_group.expects(:Add).with("WinNT://testcomputername/someone,user")
+
+        group.add_member('someone')
+      end
+
+      it "should be able to remove a member" do
+        adsi_group.expects(:Remove).with("WinNT://testcomputername/someone,user")
+
+        group.remove_member('someone')
+      end
+
+      it "should provide its groups as a list of names" do
+        names = ['user1', 'user2']
+
+        users = names.map { |name| mock('user', :Name => name) }
+
+        adsi_group.expects(:Members).returns(users)
+
+        group.members.should =~ names
+      end
+
+      it "should be able to add a list of users to a group" do
+        names = ['user1', 'user2']
+        adsi_group.expects(:Members).returns names.map{|n| stub(:Name => n)}
+
+        adsi_group.expects(:Remove).with('WinNT://testcomputername/user1,user')
+        adsi_group.expects(:Add).with('WinNT://testcomputername/user3,user')
+
+        group.set_members(['user2', 'user3'])
+      end
+
+      it "should generate the correct URI" do
+        group.uri.should == "WinNT://testcomputername/#{groupname},group"
+      end
+    end
+
+    it "should generate the correct URI" do
+      Puppet::Util::ADSI::Group.uri("people").should == "WinNT://testcomputername/people,group"
+    end
+
+    it "should be able to create a group" do
+      adsi_group = stub("adsi")
+
+      connection.expects(:Create).with('group', groupname).returns(adsi_group)
+
+      group = Puppet::Util::ADSI::Group.create(groupname)
+
+      group.should be_a(Puppet::Util::ADSI::Group)
+      group.native_group.should == adsi_group
+    end
+
+    it "should be able to confirm the existence of a group" do
+      Puppet::Util::ADSI.expects(:connect).with("WinNT://testcomputername/#{groupname},group").returns connection
+
+      Puppet::Util::ADSI::Group.exists?(groupname).should be_true
+    end
+
+    it "should be able to delete a group" do
+      connection.expects(:Delete).with('group', groupname)
+
+      Puppet::Util::ADSI::Group.delete(groupname)
+    end
+  end
+end

data/spec/unit/util/autoload_spec.rb

@@ -4,43 +4,47 @@ 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"
   end
 
-  it "should use the Cacher module" do
-    Puppet::Util::Autoload.ancestors.should be_include(Puppet::Util::Cacher)
-  end
-
   describe "when building the search path" do
+    before :each do
+      @dira = make_absolute('/a')
+      @dirb = make_absolute('/b')
+      @dirc = make_absolute('/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 "/a:/b:/c"
-      Dir.expects(:entries).with("/a").returns %w{one two}
-      Dir.expects(:entries).with("/b").returns %w{one two}
+      Puppet.settings.expects(:value).with(:modulepath, :foo).returns "#{@dira}#{File::PATH_SEPARATOR}#{@dirb}#{File::PATH_SEPARATOR}#{@dirc}"
+      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("/a").returns true
-      FileTest.expects(:directory?).with("/b").returns true
-      %w{/a/one/plugins /a/two/lib /b/one/plugins /b/two/lib}.each do |d|
+      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|
         FileTest.expects(:directory?).with(d).returns true
       end
 
-      @autoload.module_directories.should == %w{/a/one/plugins /a/two/lib /b/one/plugins /b/two/lib}
+      @autoload.module_directories.should == ["#{@dira}/one/plugins", "#{@dira}/two/lib", "#{@dirb}/one/plugins", "#{@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 "/a"
-      Dir.expects(:entries).with("/a").returns %w{. ..}
-
-      FileTest.expects(:directory?).with("/a").returns true
-      FileTest.expects(:directory?).with("/a/./lib").never
-      FileTest.expects(:directory?).with("/a/./plugins").never
-      FileTest.expects(:directory?).with("/a/../lib").never
-      FileTest.expects(:directory?).with("/a/../plugins").never
+      Puppet.settings.expects(:value).with(:modulepath, :foo).returns @dira
+      Dir.expects(:entries).with(@dira).returns %w{. ..}
+
+      FileTest.expects(:directory?).with(@dira).returns true
+      FileTest.expects(:directory?).with("#{@dira}/./lib").never
+      FileTest.expects(:directory?).with("#{@dira}/./plugins").never
+      FileTest.expects(:directory?).with("#{@dira}/../lib").never
+      FileTest.expects(:directory?).with("#{@dira}/../plugins").never
 
       @autoload.module_directories
     end