puppet 2.7.6 → 2.7.8

data/spec/unit/type/ssh_authorized_key_spec.rb

@@ -47,9 +47,8 @@ describe ssh_authorized_key, :unless => Puppet.features.microsoft_windows? do
         proc { @class.new(:name => "username@hostname", :ensure => :present, :user => "nobody") }.should_not raise_error
       end
 
-      it "should not support whitespaces" do
-        proc { @class.new(:name => "my test", :ensure => :present, :user => "nobody") }.should raise_error(Puppet::Error,/Resourcename must not contain whitespace/)
-        proc { @class.new(:name => "my\ttest", :ensure => :present, :user => "nobody") }.should raise_error(Puppet::Error,/Resourcename must not contain whitespace/)
+      it "should support whitespace" do
+        proc { @class.new(:name => "my test", :ensure => :present, :user => "nobody") }.should_not raise_error
       end
 
     end

data/spec/unit/type/user_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 
 user = Puppet::Type.type(:user)
 
-describe user, :fails_on_windows => true do
+describe user do
   before do
     ENV["PATH"] += File::PATH_SEPARATOR + "/usr/sbin" unless ENV["PATH"].split(File::PATH_SEPARATOR).include?("/usr/sbin")
     @provider = stub 'provider'
@@ -326,6 +326,7 @@ describe user, :fails_on_windows => true do
 
     it "should autorequire roles" do
       testuser = Puppet::Type.type(:user).new(:name => "testuser")
+      testuser.provider.stubs(:send).with(:roles).returns("")
       testuser[:roles] = "testrole"
 
       testrole = Puppet::Type.type(:user).new(:name => "testrole")

data/spec/unit/type_spec.rb

@@ -177,6 +177,15 @@ describe Puppet::Type, :fails_on_windows => true do
       end
     end
 
+    it "should have documentation for the 'provider' parameter if there are providers" do
+      @type.provide(:test_provider)
+      @type.paramdoc(:provider).should =~ /`provider_test_type`[\s\r]+resource/
+    end
+
+    it "should not have documentation for the 'provider' parameter if there are no providers" do
+      expect { @type.paramdoc(:provider) }.to raise_error(NoMethodError)
+    end
+
     it "should create a subclass of Puppet::Provider for the provider" do
       provider = @type.provide(:test_provider)
 
@@ -544,9 +553,44 @@ describe Puppet::Type, :fails_on_windows => true do
   it "should have a 'stage' metaparam" do
     Puppet::Type.metaparamclass(:stage).should be_instance_of(Class)
   end
+
+  describe "#suitable?" do
+    let(:type) { Puppet::Type.type(:file) }
+    let(:resource) { type.new :path => tmpfile('suitable') }
+    let(:provider) { resource.provider }
+
+    it "should be suitable if its type doesn't use providers" do
+      type.stubs(:paramclass).with(:provider).returns nil
+
+      resource.should be_suitable
+    end
+
+    it "should be suitable if it has a provider which is suitable" do
+      resource.should be_suitable
+    end
+
+    it "should not be suitable if it has a provider which is not suitable" do
+      provider.class.stubs(:suitable?).returns false
+
+      resource.should_not be_suitable
+    end
+
+    it "should be suitable if it does not have a provider and there is a default provider" do
+      resource.stubs(:provider).returns nil
+
+      resource.should be_suitable
+    end
+
+    it "should not be suitable if it doesn't have a provider and there is not default provider" do
+      resource.stubs(:provider).returns nil
+      type.stubs(:defaultprovider).returns nil
+
+      resource.should_not be_suitable
+    end
+  end
 end
 
-describe Puppet::Type::RelationshipMetaparam, :fails_on_windows => true do
+describe Puppet::Type::RelationshipMetaparam do
   include PuppetSpec::Files
 
   it "should be a subclass of Puppet::Parameter" do
@@ -557,7 +601,7 @@ describe Puppet::Type::RelationshipMetaparam, :fails_on_windows => true do
     Puppet::Type::RelationshipMetaparam.should respond_to(:subclasses)
   end
 
-  describe "when munging relationships", :'fails_on_windows' => true do
+  describe "when munging relationships", :fails_on_windows => true do
     before do
       @path = make_absolute('/foo')
       @resource = Puppet::Type.type(:mount).new :name => @path
@@ -593,7 +637,7 @@ describe Puppet::Type::RelationshipMetaparam, :fails_on_windows => true do
   end
 end
 
-describe Puppet::Type.metaparamclass(:check), :fails_on_windows => true do
+describe Puppet::Type.metaparamclass(:check) do
   include PuppetSpec::Files
 
   it "should warn and create an instance of ':audit'" do
@@ -604,7 +648,7 @@ describe Puppet::Type.metaparamclass(:check), :fails_on_windows => true do
   end
 end
 
-describe Puppet::Type.metaparamclass(:audit), :fails_on_windows => true do
+describe Puppet::Type.metaparamclass(:audit) do
   include PuppetSpec::Files
 
   before do

data/spec/unit/util/adsi_spec.rb

@@ -29,17 +29,26 @@ describe Puppet::Util::ADSI do
   end
 
   describe ".sid_for_account" do
-    it "should return the SID" do
-      result = [stub('account', :Sid => 'S-1-1-50')]
-      connection.expects(:execquery).returns(result)
+    it "should return nil if the account does not exist" do
+      connection.expects(:execquery).returns([])
 
-      Puppet::Util::ADSI.sid_for_account('joe').should == 'S-1-1-50'
+      Puppet::Util::ADSI.sid_for_account('foobar').should be_nil
     end
 
-    it "should return nil if the account does not exist" do
-        connection.expects(:execquery).returns([])
+    it "should return a SID for a passed user or group name" do
+      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('foobar').should be_nil
+      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::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
   end
 
@@ -54,6 +63,7 @@ describe Puppet::Util::ADSI do
       adsi_user = stub('adsi')
 
       connection.expects(:Create).with('user', username).returns(adsi_user)
+      Puppet::Util::ADSI::Group.expects(:exists?).with(username).returns(false)
 
       user = Puppet::Util::ADSI::User.create(username)
 
@@ -199,6 +209,7 @@ describe Puppet::Util::ADSI do
       adsi_group = stub("adsi")
 
       connection.expects(:Create).with('group', groupname).returns(adsi_group)
+      Puppet::Util::ADSI::User.expects(:exists?).with(groupname).returns(false)
 
       group = Puppet::Util::ADSI::Group.create(groupname)
 

data/spec/unit/util/checksums_spec.rb

@@ -4,6 +4,8 @@ require 'spec_helper'
 require 'puppet/util/checksums'
 
 describe Puppet::Util::Checksums do
+  include PuppetSpec::Files
+
   before do
     @summer = Object.new
     @summer.extend(Puppet::Util::Checksums)
@@ -76,7 +78,7 @@ describe Puppet::Util::Checksums do
         #fh.expects(:read).with(512).returns("secondline")
         #fh.expects(:read).with(512).returns(nil)
 
-        File.expects(:open).with(file, "r").yields(fh)
+        File.expects(:open).with(file, "rb").yields(fh)
 
         digest.expects(:<<).with "firstline"
         digest.expects(:<<).with "secondline"
@@ -94,6 +96,7 @@ describe Puppet::Util::Checksums do
           sum.should == digest
         end.should == :mydigest
       end
+
     end
   end
 
@@ -114,7 +117,7 @@ describe Puppet::Util::Checksums do
         fh = mock 'filehandle'
         fh.expects(:read).with(512).returns('my content')
 
-        File.expects(:open).with(file, "r").yields(fh)
+        File.expects(:open).with(file, "rb").yields(fh)
 
         digest.expects(:<<).with "my content"
         digest.expects(:hexdigest).returns :mydigest
@@ -154,4 +157,19 @@ describe Puppet::Util::Checksums do
       @summer.none_stream{ |checksum| checksum << "anything" ; expectation.do_something!  }.should == ""
     end
   end
+
+  {:md5 => Digest::MD5, :sha1 => Digest::SHA1}.each do |sum, klass|
+    describe "when using #{sum}" do
+      let(:content) { "hello\r\nworld" }
+      let(:path) do
+        path = tmpfile("checksum_#{sum}")
+        File.open(path, 'wb') {|f| f.write(content)}
+        path
+      end
+
+      it "should preserve nl/cr sequences" do
+        @summer.send(sum.to_s + "_file", path).should == klass.hexdigest(content)
+      end
+    end
+  end
 end

data/spec/unit/util/execution_stub_spec.rb

@@ -16,19 +16,24 @@ describe Puppet::Util::ExecutionStub do
     Puppet::Util::ExecutionStub.current_value.should == nil
   end
 
-  it "should restore normal execution after 'reset' is called", :fails_on_windows => true do
-    true_command = Puppet::Util.which('true') # Note: "true" exists at different paths in different OSes
+  it "should restore normal execution after 'reset' is called" do
+    # Note: "true" exists at different paths in different OSes
+    if Puppet.features.microsoft_windows?
+      true_command = [Puppet::Util.which('cmd.exe').tr('/', '\\'), '/c', 'exit 0']
+    else
+      true_command = [Puppet::Util.which('true')]
+    end
     stub_call_count = 0
     Puppet::Util::ExecutionStub.set do |command, options|
-      command.should == [true_command]
+      command.should == true_command
       stub_call_count += 1
       'stub called'
     end
-    Puppet::Util.execute([true_command]).should == 'stub called'
+    Puppet::Util.execute(true_command).should == 'stub called'
     stub_call_count.should == 1
     Puppet::Util::ExecutionStub.reset
     Puppet::Util::ExecutionStub.current_value.should == nil
-    Puppet::Util.execute([true_command]).should == ''
+    Puppet::Util.execute(true_command).should == ''
     stub_call_count.should == 1
   end
 end

data/spec/unit/util/logging_spec.rb

@@ -46,18 +46,18 @@ describe Puppet::Util::Logging do
       @logger.notice "foo"
     end
 
-    it "should use the path of any provided resource type", :fails_on_windows => true do
-      resource = Puppet::Type.type(:mount).new :name => "foo"
+    it "should use the path of any provided resource type" do
+      resource = Puppet::Type.type(:host).new :name => "foo"
 
-      resource.expects(:path).returns "/path/to/mount".to_sym
+      resource.expects(:path).returns "/path/to/host".to_sym
 
-      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/mount" }
+      Puppet::Util::Log.expects(:create).with { |args| args[:source] == "/path/to/host" }
 
       resource.notice "foo"
     end
 
-    it "should use the path of any provided resource parameter", :fails_on_windows => true do
-      resource = Puppet::Type.type(:mount).new :name => "foo"
+    it "should use the path of any provided resource parameter" do
+      resource = Puppet::Type.type(:host).new :name => "foo"
 
       param = resource.parameter(:name)
 

data/spec/unit/util/rdoc/parser_spec.rb

@@ -23,7 +23,7 @@ describe RDoc::Parser, :'fails_on_ruby_1.9.2' => true do
       Puppet::Parser::Parser.stubs(:new).returns(parser)
       parser.expects(:parse).returns(Puppet::Parser::AST::Hostclass.new('')).at_least_once
       parser.expects(:file=).with("module/manifests/init.pp")
-      parser.expects(:file=).with(make_absolute("/dev/null/manifests/site.pp"))
+      parser.expects(:file=).with(File.expand_path("/dev/null/manifests/site.pp"))
 
       @parser.scan
     end

data/spec/unit/util/reference_spec.rb

@@ -0,0 +1,29 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/util/reference'
+
+describe Puppet::Util::Reference do
+  it "should create valid Markdown extension definition lists" do
+    my_fragment = nil
+    Puppet::Util::Reference.newreference :testreference, :doc => "A peer of the type and configuration references, but with no useful information" do
+      my_term = "A term"
+      my_definition = <<-EOT
+The definition of this term.
+We should be able to handle multi-line definitions.
+
+We should be able to handle multi-paragraph definitions.
+      EOT
+      my_fragment = markdown_definitionlist(my_term, my_definition)
+    end
+    Puppet::Util::Reference.reference(:testreference).send(:to_markdown, true)
+    my_fragment.should == <<-EOT
+A term
+: The definition of this term.
+    We should be able to handle multi-line definitions.
+
+    We should be able to handle multi-paragraph definitions.
+
+    EOT
+  end
+
+end

data/spec/unit/util/settings/file_setting_spec.rb

@@ -173,10 +173,16 @@ describe Puppet::Util::Settings::FileSetting do
       @file.to_resource.title.should == path
     end
 
-    it "should set the mode on the file if a mode is provided" do
+    it "should set the mode on the file if a mode is provided as an octal number" do
       @file.mode = 0755
 
-      @file.to_resource[:mode].should == 0755
+      @file.to_resource[:mode].should == '755'
+    end
+
+    it "should set the mode on the file if a mode is provided as a string" do
+      @file.mode = '0755'
+
+      @file.to_resource[:mode].should == '755'
     end
 
     it "should not set the mode on a the file if manage_internal_file_permissions is disabled" do

data/spec/unit/util_spec.rb

@@ -3,6 +3,8 @@
 require 'spec_helper'
 
 describe Puppet::Util do
+  include PuppetSpec::Files
+
   def process_status(exitstatus)
     return exitstatus if Puppet.features.microsoft_windows?
 
@@ -445,4 +447,117 @@ describe Puppet::Util do
       end
     end
   end
+
+  describe "#which" do
+    let(:base) { File.expand_path('/bin') }
+    let(:path) { File.join(base, 'foo') }
+
+    before :each do
+      FileTest.stubs(:file?).returns false
+      FileTest.stubs(:file?).with(path).returns true
+
+      FileTest.stubs(:executable?).returns false
+      FileTest.stubs(:executable?).with(path).returns true
+    end
+
+    it "should accept absolute paths" do
+      Puppet::Util.which(path).should == path
+    end
+
+    it "should return nil if no executable found" do
+      Puppet::Util.which('doesnotexist').should be_nil
+    end
+
+    it "should reject directories" do
+      Puppet::Util.which(base).should be_nil
+    end
+
+    describe "on POSIX systems" do
+      before :each do
+        Puppet.features.stubs(:posix?).returns true
+        Puppet.features.stubs(:microsoft_windows?).returns false
+      end
+
+      it "should walk the search PATH returning the first executable" do
+        ENV.stubs(:[]).with('PATH').returns(File.expand_path('/bin'))
+
+        Puppet::Util.which('foo').should == path
+      end
+    end
+
+    describe "on Windows systems" do
+      let(:path) { File.expand_path(File.join(base, 'foo.CMD')) }
+
+      before :each do
+        Puppet.features.stubs(:posix?).returns false
+        Puppet.features.stubs(:microsoft_windows?).returns true
+      end
+
+      describe "when a file extension is specified" do
+        it "should walk each directory in PATH ignoring PATHEXT" do
+          ENV.stubs(:[]).with('PATH').returns(%w[/bar /bin].map{|dir| File.expand_path(dir)}.join(File::PATH_SEPARATOR))
+
+          FileTest.expects(:file?).with(File.join(File.expand_path('/bar'), 'foo.CMD')).returns false
+
+          ENV.expects(:[]).with('PATHEXT').never
+          Puppet::Util.which('foo.CMD').should == path
+        end
+      end
+
+      describe "when a file extension is not specified" do
+        it "should walk each extension in PATHEXT until an executable is found" do
+          bar = File.expand_path('/bar')
+          ENV.stubs(:[]).with('PATH').returns("#{bar}#{File::PATH_SEPARATOR}#{base}")
+          ENV.stubs(:[]).with('PATHEXT').returns(".EXE#{File::PATH_SEPARATOR}.CMD")
+
+          exts = sequence('extensions')
+          FileTest.expects(:file?).in_sequence(exts).with(File.join(bar, 'foo.EXE')).returns false
+          FileTest.expects(:file?).in_sequence(exts).with(File.join(bar, 'foo.CMD')).returns false
+          FileTest.expects(:file?).in_sequence(exts).with(File.join(base, 'foo.EXE')).returns false
+          FileTest.expects(:file?).in_sequence(exts).with(path).returns true
+
+          Puppet::Util.which('foo').should == path
+        end
+
+        it "should walk the default extension path if the environment variable is not defined" do
+          ENV.stubs(:[]).with('PATH').returns(base)
+          ENV.stubs(:[]).with('PATHEXT').returns(nil)
+
+          exts = sequence('extensions')
+          %w[.COM .EXE .BAT].each do |ext|
+            FileTest.expects(:file?).in_sequence(exts).with(File.join(base, "foo#{ext}")).returns false
+          end
+          FileTest.expects(:file?).in_sequence(exts).with(path).returns true
+
+          Puppet::Util.which('foo').should == path
+        end
+
+        it "should fall back if no extension matches" do
+          ENV.stubs(:[]).with('PATH').returns(base)
+          ENV.stubs(:[]).with('PATHEXT').returns(".EXE")
+
+          FileTest.stubs(:file?).with(File.join(base, 'foo.EXE')).returns false
+          FileTest.stubs(:file?).with(File.join(base, 'foo')).returns true
+          FileTest.stubs(:executable?).with(File.join(base, 'foo')).returns true
+
+          Puppet::Util.which('foo').should == File.join(base, 'foo')
+        end
+      end
+    end
+  end
+
+  describe "#binread" do
+    let(:contents) { "foo\r\nbar" }
+
+    it "should preserve line endings" do
+      path = tmpfile('util_binread')
+      File.open(path, 'wb') { |f| f.print contents }
+
+      Puppet::Util.binread(path).should == contents
+    end
+
+    it "should raise an error if the file doesn't exist" do
+      expect { Puppet::Util.binread('/path/does/not/exist') }.to raise_error(Errno::ENOENT)
+    end
+  end
 end