puppet 3.3.2 → 3.4.0.rc1

data/spec/unit/type/package_spec.rb

@@ -51,7 +51,7 @@ describe Puppet::Type.type(:package) do
         :clear           => nil,
         :validate_source => nil
       )
-      Puppet::Type.type(:package).defaultprovider.expects(:new).returns(@provider)
+      Puppet::Type.type(:package).defaultprovider.stubs(:new).returns(@provider)
     end
 
     it "should support :present as a value to :ensure" do
@@ -100,6 +100,12 @@ describe Puppet::Type.type(:package) do
     it "should accept any string as an argument to :source" do
       expect { Puppet::Type.type(:package).new(:name => "yay", :source => "stuff") }.to_not raise_error
     end
+
+    it "should not accept a non-string name" do
+      expect do
+        Puppet::Type.type(:package).new(:name => ["error"])
+      end.to raise_error(Puppet::ResourceError, /Name must be a String/)
+    end
   end
 
   module PackageEvaluationTesting

data/spec/unit/type/schedule_spec.rb

@@ -62,6 +62,12 @@ describe Puppet::Type.type(:schedule) do
       end
     end
 
+    it "should not produce default schedules when default_schedules is false"  do
+      Puppet[:default_schedules] = false
+      schedules = Puppet::Type.type(:schedule).mkdefaultschedules
+      schedules.must have_exactly(0).items
+    end
+
     it "should produce a schedule named puppet with a period of hourly and a repeat of 2" do
       schedules = Puppet::Type.type(:schedule).mkdefaultschedules
       schedules.find { |s|

data/spec/unit/type/service_spec.rb

@@ -120,14 +120,14 @@ describe Puppet::Type.type(:service), "when validating attribute values" do
   end
 
   it "should split paths on '#{File::PATH_SEPARATOR}'" do
-    FileTest.stubs(:exist?).returns(true)
+    Puppet::FileSystem::File.stubs(:exist?).returns(true)
     FileTest.stubs(:directory?).returns(true)
     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 '#{File::PATH_SEPARATOR}'" do
-    FileTest.stubs(:exist?).returns(true)
+    Puppet::FileSystem::File.stubs(:exist?).returns(true)
     FileTest.stubs(:directory?).returns(true)
     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}
@@ -137,7 +137,7 @@ end
 describe Puppet::Type.type(:service), "when setting default attribute values" do
   it "should default to the provider's default path if one is available" do
     FileTest.stubs(:directory?).returns(true)
-    FileTest.stubs(:exist?).returns(true)
+    Puppet::FileSystem::File.stubs(:exist?).returns(true)
 
     Puppet::Type.type(:service).defaultprovider.stubs(:respond_to?).returns(true)
     Puppet::Type.type(:service).defaultprovider.stubs(:defpath).returns("testing")

data/spec/unit/type/tidy_spec.rb

@@ -10,17 +10,15 @@ describe tidy do
   before do
     @basepath = make_absolute("/what/ever")
     Puppet.settings.stubs(:use)
-
-    # for an unknown reason some of these specs fails when run individually
-    # with a failed expectation on File.lstat in the autoloader.
-    File.stubs(:lstat)
   end
 
   it "should use :lstat when stating a file" do
-    resource = tidy.new :path => "/foo/bar", :age => "1d"
+    path = '/foo/bar'
+    resource = tidy.new :path => path, :age => "1d"
     stat = mock 'stat'
-    File.expects(:lstat).with("/foo/bar").returns stat
-    resource.stat("/foo/bar").should == stat
+    stub_file = stub(path, :lstat => stat)
+    Puppet::FileSystem::File.expects(:new).with(path).returns stub_file
+    resource.stat(path).should == stat
   end
 
   [:age, :size, :path, :matches, :type, :recurse, :rmdirs].each do |param|
@@ -130,7 +128,8 @@ describe tidy do
     before do
       @tidy = Puppet::Type.type(:tidy).new :path => @basepath
       @stat = stub 'stat', :ftype => "directory"
-      File.stubs(:lstat).with(@basepath).returns @stat
+      @stub_file = stub(@basepath, :lstat => @stat)
+      Puppet::FileSystem::File.stubs(:new).with(@basepath).returns @stub_file
     end
 
     describe "and generating files" do
@@ -160,7 +159,7 @@ describe tidy do
       end
 
       it "should do nothing if the targeted file does not exist" do
-        File.expects(:lstat).with(@basepath).raises Errno::ENOENT
+        @stub_file.expects(:lstat).raises Errno::ENOENT
 
         @tidy.generate.should == []
       end
@@ -311,32 +310,33 @@ describe tidy do
       before do
         @tidy = Puppet::Type.type(:tidy).new :path => @basepath
         @stat = stub 'stat', :ftype => "file"
-        File.stubs(:lstat).with(@basepath).returns @stat
+        @stub_file = stub(@basepath, :lstat => @stat)
+        Puppet::FileSystem::File.expects(:new).with(@basepath).returns @stub_file
       end
 
       it "should not try to recurse if the file does not exist" do
         @tidy[:recurse] = true
 
-        File.stubs(:lstat).with(@basepath).returns nil
+        @stub_file.stubs(:lstat).returns nil
 
         @tidy.generate.should == []
       end
 
       it "should not be tidied if the file does not exist" do
-        File.expects(:lstat).with(@basepath).raises Errno::ENOENT
+        @stub_file.expects(:lstat).raises Errno::ENOENT
 
         @tidy.should_not be_tidy(@basepath)
       end
 
       it "should not be tidied if the user has no access to the file" do
-        File.expects(:lstat).with(@basepath).raises Errno::EACCES
+        @stub_file.expects(:lstat).raises Errno::EACCES
 
         @tidy.should_not be_tidy(@basepath)
       end
 
       it "should not be tidied if it is a directory and rmdirs is set to false" do
         stat = mock 'stat', :ftype => "directory"
-        File.expects(:lstat).with(@basepath).returns stat
+        @stub_file.expects(:lstat).returns stat
 
         @tidy.should_not be_tidy(@basepath)
       end

data/spec/unit/type/user_spec.rb

@@ -339,6 +339,15 @@ describe Puppet::Type.type(:user) do
     end
   end
 
+  describe "when managing comment on Ruby 1.9", :if => String.respond_to?(:encode) do
+    it "should force value encoding to ASCII-8BIT" do
+      value = 'abcd'.encode(Encoding::UTF_8)
+      comment = described_class.new(:name => 'foo', :comment => value)
+      comment[:comment].should == 'abcd'
+      comment[:comment].encoding.should == Encoding::ASCII_8BIT
+    end
+  end
+
   describe "when manages_solaris_rbac is enabled" do
     it "should support a :role value for ensure" do
       expect { described_class.new(:name => 'foo', :ensure => :role) }.to_not raise_error

data/spec/unit/type_spec.rb

@@ -1,9 +1,10 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-
+require 'puppet_spec/compiler'
 
 describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
+  include PuppetSpec::Compiler
 
   it "should be Comparable" do
     a = Puppet::Type.type(:notify).new(:name => "a")
@@ -63,6 +64,28 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
   end
 
+  it "can retrieve all set parameters" do
+    resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present, :tag => 'foo')
+    params = resource.parameters_with_value
+    [:name, :provider, :ensure, :fstype, :pass, :dump, :target, :loglevel, :tag].each do |name|
+      params.should be_include(resource.parameter(name))
+    end
+  end
+
+  it "can not return any `nil` values when retrieving all set parameters" do
+    resource = Puppet::Type.type(:mount).new(:name => "foo", :fstype => "bar", :pass => 1, :ensure => :present, :tag => 'foo')
+    params = resource.parameters_with_value
+    params.should_not be_include(nil)
+  end
+
+  it "can return an iterator for all set parameters" do
+    resource = Puppet::Type.type(:notify).new(:name=>'foo',:message=>'bar',:tag=>'baz',:require=> "File['foo']")
+    params = [:name, :message, :withpath, :loglevel, :tag, :require]
+    resource.eachparameter { |param|
+      params.should be_include(param.to_s.to_sym)
+    }
+  end
+
   it "should have a method for setting default values for resources" do
     Puppet::Type.type(:mount).new(:name => "foo").must respond_to(:set_default)
   end
@@ -109,6 +132,36 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     Puppet::Type.type(:mount).new(:name => "foo").version.should == 0
   end
 
+  it "reports the correct path even after path is used during setup of the type" do
+    Puppet::Type.newtype(:testing) do
+      newparam(:name) do
+        isnamevar
+        validate do |value|
+          path # forces the computation of the path
+        end
+      end
+    end
+
+    ral = compile_to_ral(<<-MANIFEST)
+      class something {
+        testing { something: }
+      }
+      include something
+    MANIFEST
+
+    ral.resource("Testing[something]").path.should == "/Stage[main]/Something/Testing[something]"
+  end
+
+  context "alias metaparam" do
+    it "creates a new name that can be used for resource references" do
+      ral = compile_to_ral(<<-MANIFEST)
+        notify { a: alias => c }
+      MANIFEST
+
+      expect(ral.resource("Notify[a]")).to eq(ral.resource("Notify[c]"))
+    end
+  end
+
   context "resource attributes" do
     let(:resource) {
       resource = Puppet::Type.type(:mount).new(:name => "foo")
@@ -123,7 +176,8 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
 
     it "should have tags" do
-      resource.tags.should == ["mount", "foo"]
+      expect(resource).to be_tagged("mount")
+      expect(resource).to be_tagged("foo")
     end
 
     it "should have a path" do
@@ -165,13 +219,19 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       @resource.event.default_log_level.should == :warning
     end
 
-    {:file => "/my/file", :line => 50, :tags => %{foo bar}}.each do |attr, value|
+    {:file => "/my/file", :line => 50}.each do |attr, value|
       it "should set the #{attr}" do
         @resource.stubs(attr).returns value
         @resource.event.send(attr).should == value
       end
     end
 
+    it "should set the tags" do
+      @resource.tag("abc", "def")
+      @resource.event.should be_tagged("abc")
+      @resource.event.should be_tagged("def")
+    end
+
     it "should allow specification of event attributes" do
       @resource.event(:status => "noop").status.should == "noop"
     end
@@ -470,6 +530,28 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
     end
   end
 
+  describe "when #finish is called on a type" do
+    let(:post_hook_type) do
+      Puppet::Type.newtype(:finish_test) do
+        newparam(:name) { isnamevar }
+
+        newparam(:post) do
+          def post_compile
+            raise "post_compile hook ran"
+          end
+        end
+      end
+    end
+
+    let(:post_hook_resource) do
+      post_hook_type.new(:name => 'foo',:post => 'fake_value')
+    end
+
+    it "should call #post_compile on parameters that implement it" do
+      expect { post_hook_resource.finish }.to raise_error(RuntimeError, "post_compile hook ran")
+    end
+  end
+
   it "should have a class method for converting a hash into a Puppet::Resource instance" do
     Puppet::Type.type(:mount).must respond_to(:hash2resource)
   end
@@ -588,7 +670,7 @@ describe Puppet::Type, :unless => Puppet.features.microsoft_windows? do
       resource.should be_a Puppet::Resource
       resource[:fstype].should   == 15
       resource[:remounts].should == :true
-      resource.tags.should       =~ %w{foo bar baz mount}
+      resource.tags.should == Puppet::Util::TagSet.new(%w{foo bar baz mount})
     end
   end
 

data/spec/unit/util/adsi_spec.rb

@@ -52,13 +52,48 @@ describe Puppet::Util::ADSI do
     end
   end
 
+  describe ".sid_uri", :if => Puppet.features.microsoft_windows? do
+    it "should raise an error when the input is not a SID object" do
+      [Object.new, {}, 1, :symbol, '', nil].each do |input|
+        expect {
+          Puppet::Util::ADSI.sid_uri(input)
+        }.to raise_error(Puppet::Error, /Must use a valid SID object/)
+      end
+    end
+
+    it "should return a SID uri for a well-known SID (SYSTEM)" do
+      sid = Win32::Security::SID.new('SYSTEM')
+      Puppet::Util::ADSI.sid_uri(sid).should == 'WinNT://S-1-5-18'
+    end
+  end
+
   describe Puppet::Util::ADSI::User do
     let(:username)  { 'testuser' }
+    let(:domain)    { 'DOMAIN' }
+    let(:domain_username) { "#{domain}\\#{username}"}
 
     it "should generate the correct URI" do
       Puppet::Util::ADSI::User.uri(username).should == "WinNT://./#{username},user"
     end
 
+    it "should generate the correct URI for a user with a domain" do
+      Puppet::Util::ADSI::User.uri(username, domain).should == "WinNT://#{domain}/#{username},user"
+    end
+
+    it "should be able to parse a username without a domain" do
+      Puppet::Util::ADSI::User.parse_name(username).should == [username, '.']
+    end
+
+    it "should be able to parse a username with a domain" do
+      Puppet::Util::ADSI::User.parse_name(domain_username).should == [username, domain]
+    end
+
+    it "should raise an error with a username that contains a /" do
+      expect {
+        Puppet::Util::ADSI::User.parse_name("#{domain}/#{username}")
+      }.to raise_error(Puppet::Error, /Value must be in DOMAIN\\user style syntax/)
+    end
+
     it "should be able to create a user" do
       adsi_user = stub('adsi')
 
@@ -76,6 +111,11 @@ describe Puppet::Util::ADSI do
       Puppet::Util::ADSI::User.exists?(username).should be_true
     end
 
+    it "should be able to check the existence of a domain user" do
+      Puppet::Util::ADSI.expects(:connect).with("WinNT://#{domain}/#{username},user").returns connection
+      Puppet::Util::ADSI::User.exists?(domain_username).should be_true
+    end
+
     it "should be able to delete a user" do
       connection.expects(:Delete).with('user', username)
 
@@ -99,7 +139,8 @@ describe Puppet::Util::ADSI do
     end
 
     describe "an instance" do
-      let(:adsi_user) { stub 'user' }
+      let(:adsi_user) { stub('user', :objectSID => []) }
+      let(:sid)       { stub(:account => username, :domain => 'testcomputername') }
       let(:user)      { Puppet::Util::ADSI::User.new(username, adsi_user) }
 
       it "should provide its groups as a list of names" do
@@ -133,14 +174,16 @@ describe Puppet::Util::ADSI do
         user.password = 'pwd'
       end
 
-      it "should generate the correct URI" do
-        user.uri.should == "WinNT://./#{username},user"
+      it "should generate the correct URI",:if => Puppet.features.microsoft_windows? do
+        Puppet::Util::Windows::Security.stubs(:octet_string_to_sid_object).returns(sid)
+        user.uri.should == "WinNT://testcomputername/#{username},user"
       end
 
-      describe "when given a set of groups to which to add the user" do
+      describe "when given a set of groups to which to add the user", :if => Puppet.features.microsoft_windows? do
         let(:groups_to_set) { 'group1,group2' }
 
         before(:each) do
+          Puppet::Util::Windows::Security.stubs(:octet_string_to_sid_object).returns(sid)
           user.expects(:groups).returns ['group2', 'group3']
         end
 
@@ -152,6 +195,7 @@ describe Puppet::Util::ADSI do
             group3 = stub 'group1'
             group3.expects(:Remove).with("WinNT://testcomputername/#{username},user")
 
+            Puppet::Util::ADSI.expects(:sid_uri).with(sid).returns("WinNT://testcomputername/#{username},user").twice
             Puppet::Util::ADSI.expects(:connect).with('WinNT://./group1,group').returns group1
             Puppet::Util::ADSI.expects(:connect).with('WinNT://./group3,group').returns group3
 
@@ -164,6 +208,7 @@ describe Puppet::Util::ADSI do
             group1 = stub 'group1'
             group1.expects(:Add).with("WinNT://testcomputername/#{username},user")
 
+            Puppet::Util::ADSI.expects(:sid_uri).with(sid).returns("WinNT://testcomputername/#{username},user")
             Puppet::Util::ADSI.expects(:connect).with('WinNT://./group1,group').returns group1
 
             user.set_groups(groups_to_set, true)
@@ -179,19 +224,58 @@ describe Puppet::Util::ADSI do
     describe "an instance" do
       let(:adsi_group) { stub 'group' }
       let(:group)      { Puppet::Util::ADSI::Group.new(groupname, adsi_group) }
+      let(:someone_sid){ stub(:account => 'someone', :domain => 'testcomputername')}
+
+      it "should be able to add a member (deprecated)", :if => Puppet.features.microsoft_windows? do
+        Puppet.expects(:deprecation_warning).with('Puppet::Util::ADSI::Group#add_members is deprecated; please use Puppet::Util::ADSI::Group#add_member_sids')
+
+        Puppet::Util::Windows::Security.expects(:name_to_sid_object).with('someone').returns(someone_sid)
+        Puppet::Util::ADSI.expects(:sid_uri).with(someone_sid).returns("WinNT://testcomputername/someone,user")
 
-      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
+      it "should raise when adding a member that can't resolve to a SID (deprecated)", :if => Puppet.features.microsoft_windows? do
+        expect {
+          group.add_member('foobar')
+        }.to raise_error(Puppet::Error, /Could not resolve username: foobar/)
+      end
+
+      it "should be able to remove a member (deprecated)", :if => Puppet.features.microsoft_windows? do
+        Puppet.expects(:deprecation_warning).with('Puppet::Util::ADSI::Group#remove_members is deprecated; please use Puppet::Util::ADSI::Group#remove_member_sids')
+
+        Puppet::Util::Windows::Security.expects(:name_to_sid_object).with('someone').returns(someone_sid)
+        Puppet::Util::ADSI.expects(:sid_uri).with(someone_sid).returns("WinNT://testcomputername/someone,user")
+
         adsi_group.expects(:Remove).with("WinNT://testcomputername/someone,user")
 
         group.remove_member('someone')
       end
 
+      it "should raise when removing a member that can't resolve to a SID (deprecated)", :if => Puppet.features.microsoft_windows? do
+        expect {
+          group.remove_member('foobar')
+        }.to raise_error(Puppet::Error, /Could not resolve username: foobar/)
+      end
+
+      describe "should be able to use SID objects", :if => Puppet.features.microsoft_windows? do
+        let(:system)     { Puppet::Util::Windows::Security.name_to_sid_object('SYSTEM') }
+
+        it "to add a member" do
+          adsi_group.expects(:Add).with("WinNT://S-1-5-18")
+
+          group.add_member_sids(system)
+        end
+
+        it "to remove a member" do
+          adsi_group.expects(:Remove).with("WinNT://S-1-5-18")
+
+          group.remove_member_sids(system)
+        end
+      end
+
       it "should provide its groups as a list of names" do
         names = ['user1', 'user2']
 
@@ -202,14 +286,38 @@ describe Puppet::Util::ADSI do
         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)}
+      it "should be able to add a list of users to a group", :if => Puppet.features.microsoft_windows? do
+        names = ['DOMAIN\user1', 'user2']
+        sids = [
+          stub(:account => 'user1', :domain => 'DOMAIN'),
+          stub(:account => 'user2', :domain => 'testcomputername'),
+          stub(:account => 'user3', :domain => 'DOMAIN2'),
+        ]
+
+        # use stubbed objectSid on member to return stubbed SID
+        Puppet::Util::Windows::Security.expects(:octet_string_to_sid_object).with([0]).returns(sids[0])
+        Puppet::Util::Windows::Security.expects(:octet_string_to_sid_object).with([1]).returns(sids[1])
 
-        adsi_group.expects(:Remove).with('WinNT://testcomputername/user1,user')
-        adsi_group.expects(:Add).with('WinNT://testcomputername/user3,user')
+        Puppet::Util::Windows::Security.expects(:name_to_sid_object).with('user2').returns(sids[1])
+        Puppet::Util::Windows::Security.expects(:name_to_sid_object).with('DOMAIN2\user3').returns(sids[2])
+
+        Puppet::Util::ADSI.expects(:sid_uri).with(sids[0]).returns("WinNT://DOMAIN/user1,user")
+        Puppet::Util::ADSI.expects(:sid_uri).with(sids[2]).returns("WinNT://DOMAIN2/user3,user")
+
+        members = names.each_with_index.map{|n,i| stub(:Name => n, :objectSID => [i])}
+        adsi_group.expects(:Members).returns members
+
+        adsi_group.expects(:Remove).with('WinNT://DOMAIN/user1,user')
+        adsi_group.expects(:Add).with('WinNT://DOMAIN2/user3,user')
+
+        group.set_members(['user2', 'DOMAIN2\user3'])
+      end
 
-        group.set_members(['user2', 'user3'])
+      it "should raise an error when a username does not resolve to a SID", :if => Puppet.features.microsoft_windows? do
+        expect {
+          adsi_group.expects(:Members).returns []
+          group.set_members(['foobar'])
+        }.to raise_error(Puppet::Error, /Could not resolve username: foobar/)
       end
 
       it "should generate the correct URI" do