puppet 3.0.0.rc5 → 3.0.0.rc7

data/spec/unit/ssl/key_spec.rb

@@ -16,10 +16,6 @@ describe Puppet::SSL::Key do
     @class.indirection.name.should == :key
   end
 
-  it "should default to the :file terminus" do
-    @class.indirection.terminus_class.should == :file
-  end
-
   it "should only support the text format" do
     @class.supported_formats.should == [:s]
   end

data/spec/unit/type/exec_spec.rb

@@ -280,7 +280,7 @@ describe Puppet::Type.type(:exec) do
 
         it "should fail if the provider calls the command invalid" do
           expect { test(command, false) }.
-            to raise_error Puppet::Error, /Parameter #{@param} failed: from a stub/
+            to raise_error Puppet::Error, /Parameter #{@param} failed on Exec\[.*\]: from a stub/
         end
       end
     end

data/spec/unit/type/file_spec.rb

@@ -142,7 +142,8 @@ describe Puppet::Type.type(:file) do
     end
 
     it "should not allow numbers" do
-      expect { file[:recurse] = 10 }.to raise_error(Puppet::Error, "Parameter recurse failed: Invalid recurse value 10")
+      expect { file[:recurse] = 10 }.to raise_error(
+        Puppet::Error, /Parameter recurse failed on File\[[^\]]+\]: Invalid recurse value 10/)
     end
 
     [false, "false"].each do |value|

data/spec/unit/type/scheduled_task_spec.rb

@@ -34,7 +34,7 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
         described_class.new(:name => 'Test Task', :command => 'notepad.exe')
       }.to raise_error(
         Puppet::Error,
-        /Parameter command failed: Must be specified using an absolute path\./
+        /Parameter command failed on Scheduled_task\[Test Task\]: Must be specified using an absolute path\./
       )
     end
   end
@@ -77,7 +77,7 @@ describe Puppet::Type.type(:scheduled_task), :if => Puppet.features.microsoft_wi
         )
       }.to raise_error(
         Puppet::Error,
-        /Parameter working_dir failed: Must be specified using an absolute path/
+        /Parameter working_dir failed on Scheduled_task\[Test Task\]: Must be specified using an absolute path/
       )
     end
 

data/spec/unit/type/zone_spec.rb

@@ -55,16 +55,6 @@ describe Puppet::Type.type(:zone) do
     described_class.new(:name => "dummy", :path => "/dummy", :ip => "if", :iptype => :exclusive, :provider => :solaris)
   end
 
-  context "state_name" do
-    it "should correctly fetch alias from state_aliases when available" do
-      zone.parameter(:ensure).class.state_name('incomplete').should == :installed
-    end
-
-    it "should correctly use symbol when alias is unavailable" do
-      zone.parameter(:ensure).class.state_name('noalias').should == :noalias
-    end
-  end
-
   it "should auto-require :dataset entries" do
     fs = 'random-pool/some-zfs'
 
@@ -81,4 +71,56 @@ describe Puppet::Type.type(:zone) do
 
     catalog.relationship_graph.dependencies(zone).should == [zfs]
   end
+  describe StateMachine do
+    let (:sm) { StateMachine.new }
+    before :each do
+      sm.insert_state :absent, :down => :destroy
+      sm.insert_state :configured, :up => :configure, :down => :uninstall
+      sm.insert_state :installed, :up => :install, :down => :stop
+      sm.insert_state :running, :up => :start
+    end
+
+    context ":insert_state" do
+      it "should insert state in correct order" do
+        sm.insert_state :dummy, :left => :right
+        sm.index(:dummy).should == 4
+      end
+    end
+    context ":alias_state" do
+      it "should alias state" do
+        sm.alias_state :dummy, :running
+        sm.name(:dummy).should == :running
+      end
+    end
+    context ":name" do
+      it "should get an aliased state correctly" do
+        sm.alias_state :dummy, :running
+        sm.name(:dummy).should == :running
+      end
+      it "should get an un aliased state correctly" do
+        sm.name(:dummy).should == :dummy
+      end
+    end
+    context ":index" do
+      it "should return the state index correctly" do
+        sm.insert_state :dummy, :left => :right
+        sm.index(:dummy).should == 4
+      end
+    end
+    context ":sequence" do
+      it "should correctly return the actions to reach state specified" do
+        sm.sequence(:absent, :running).map{|p|p[:up]}.should ==  [:configure,:install,:start]
+      end
+      it "should correctly return the actions to reach state specified(2)" do
+        sm.sequence(:running, :absent).map{|p|p[:down]}.should == [:stop, :uninstall, :destroy]
+      end
+    end
+    context ":cmp" do
+      it "should correctly compare state sequence values" do
+        sm.cmp?(:absent, :running).should == true
+        sm.cmp?(:running, :running).should == false
+        sm.cmp?(:running, :absent).should == false
+      end
+    end
+  end
 end

data/spec/unit/util/adsi_spec.rb

@@ -229,4 +229,23 @@ 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/checksums_spec.rb

@@ -92,11 +92,10 @@ describe Puppet::Util::Checksums do
         klass.expects(:new).returns digest
         digest.expects(:hexdigest).returns :mydigest
 
-        @summer.send(sum.to_s + "_stream") do |sum|
-          sum.should == digest
+        @summer.send(sum.to_s + "_stream") do |checksum|
+          checksum.should == digest
         end.should == :mydigest
       end
-
     end
   end
 

data/spec/unit/util/execution_spec.rb

@@ -265,7 +265,7 @@ describe Puppet::Util::Execution do
           Process.expects(:CloseHandle).with(thread_handle)
           Process.expects(:CloseHandle).with(process_handle)
 
-          expect { Puppet::Util::Execution.execute('test command') }.should raise_error(RuntimeError)
+          expect { Puppet::Util::Execution.execute('test command') }.to raise_error(RuntimeError)
         end
       end
     end

data/spec/unit/util/log/destinations_spec.rb

@@ -28,6 +28,7 @@ describe Puppet::Util::Log.desttypes[:file] do
 
   before do
     File.stubs(:open)           # prevent actually creating the file
+    File.stubs(:chown)          # prevent chown on non existing file from failing 
     @class = Puppet::Util::Log.desttypes[:file]
   end
 

data/spec/unit/util/log/rate_limited_logger_spec.rb

@@ -0,0 +1,51 @@
+#!/usr/bin/env ruby -S rspec
+require 'spec_helper'
+require 'puppet/util/log/rate_limited_logger'
+
+describe Puppet::Util::Log::RateLimitedLogger do
+
+  subject { Puppet::Util::Log::RateLimitedLogger.new(60) }
+
+  before do
+    Time.stubs(:now).returns(0)
+  end
+
+  it "should be able to log all levels" do
+    Puppet::Util::Log.eachlevel do |level|
+      subject.should respond_to(level)
+    end
+  end
+
+  it "should fail if given an invalid time interval" do
+    expect { Puppet::Util::Log::RateLimitedLogger.new('foo') }.to raise_error(ArgumentError)
+  end
+
+  it "should not log the same message more than once within the given interval" do
+    Puppet::Util::Log.expects(:create).once
+    subject.info('foo')
+    subject.info('foo')
+  end
+
+  it "should allow the same message to be logged after the given interval has passed" do
+    Puppet::Util::Log.expects(:create).twice
+    subject.info('foo')
+    Time.stubs(:now).returns(60)
+    subject.info('foo')
+  end
+
+  it "should rate-limit different message strings separately" do
+    Puppet::Util::Log.expects(:create).times(3)
+    subject.info('foo')
+    subject.info('bar')
+    subject.info('baz')
+    subject.info('foo')
+    subject.info('bar')
+    subject.info('baz')
+  end
+
+  it "should limit the same message in different log levels independently" do
+    Puppet::Util::Log.expects(:create).twice
+    subject.info('foo')
+    subject.warning('foo')
+  end
+end

data/spec/unit/util/logging_spec.rb

@@ -133,18 +133,18 @@ describe Puppet::Util::Logging do
       exc1.set_backtrace(["7.rb:31:in `e'","8.rb:22:in `f'","9.rb:9"])
       # whoa ugly
       @logger.format_exception(exc1).should =~ /third
-.*7\.rb:31
-.*8\.rb:22
+.*7\.rb:31:in `e'
+.*8\.rb:22:in `f'
 .*9\.rb:9
 Wrapped exception:
 second
-.*4\.rb:8
-.*5\.rb:1
+.*4\.rb:8:in `c'
+.*5\.rb:1:in `d'
 .*6\.rb:3
 Wrapped exception:
 original
-.*1\.rb:4
-.*2\.rb:2
+.*1\.rb:4:in `a'
+.*2\.rb:2:in `b'
 .*3\.rb:1/
     end
   end

data/spec/unit/util/selinux_spec.rb

@@ -1,6 +1,7 @@
 #! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
+require 'pathname'
 require 'puppet/util/selinux'
 include Puppet::Util::SELinux
 
@@ -33,7 +34,7 @@ describe Puppet::Util::SELinux do
     end
   end
 
-  describe "filesystem detection" do
+  describe "read_mounts" do
     before :each do
       fh = stub 'fh', :close => nil
       File.stubs(:open).with("/proc/mounts").returns fh
@@ -48,6 +49,17 @@ describe Puppet::Util::SELinux do
         '/proc' => 'proc',
         '/dev' => 'tmpfs' }
     end
+  end
+
+  describe "filesystem detection" do
+    before :each do
+      self.stubs(:read_mounts).returns({
+        '/'        => 'ext3',
+        '/sys'     => 'sysfs',
+        '/mnt/nfs' => 'nfs',
+        '/proc'    => 'proc',
+        '/dev'     => 'tmpfs' })
+    end
 
     it "should match a path on / to ext3" do
       find_fs('/etc/puppet/testfile').should == "ext3"
@@ -65,41 +77,21 @@ describe Puppet::Util::SELinux do
       selinux_label_support?('/mnt/nfs/testfile').should be_false
     end
 
-    it "should follow symlinks when determining file systems" do
-      self.stubs(:realpath).with('/mnt/symlink/testfile').returns('/mnt/nfs/dest/testfile')
+    it "(#8714) don't follow symlinks when determining file systems", :unless => Puppet.features.microsoft_windows? do
+      scratch = Pathname(PuppetSpec::Files.tmpdir('selinux'))
 
-      selinux_label_support?('/mnt/symlink/testfile').should be_false
-    end
+      self.stubs(:read_mounts).returns({
+          '/'             => 'ext3',
+          scratch + 'nfs' => 'nfs',
+        })
 
-  end
+      (scratch + 'foo').make_symlink('nfs/bar')
+      selinux_label_support?(scratch + 'foo').should be_true
+    end
 
-  describe "realpath" do
     it "should handle files that don't exist" do
-
-      # Since I'm stubbing Pathname.new for this test,
-      # I need to also stub the internal calls to Pathname.new,
-      # which happen in Pathname.dirname and Parthname.basename
-      # I want those to return real Pathname objects,
-      # so I'm creating them before the stub is in place.
-      realpaths = Hash.new {|hash, path| hash[path] = Pathname.new(path) }
-      paths = ['symlink', '/mnt']
-      paths.each { |path| realpaths[path] }
-
-      realpaths['/mnt/symlink'] = stubs "Pathname"
-      realpaths['/mnt/symlink'].stubs(:realpath).returns(realpaths['/mnt/nfs/dest'])
-      realpaths['/mnt/symlink'].stubs(:exist?).returns(true)
-
-      realpaths['/mnt/symlink/nonexistant'] = stubs "Pathname"
-      realpaths['/mnt/symlink/nonexistant'].stubs(:realpath).raises(Errno::ENOENT)
-      realpaths['/mnt/symlink/nonexistant'].stubs(:exist?).returns(false)
-      realpaths['/mnt/symlink/nonexistant'].stubs(:dirname).returns(realpaths['/mnt/symlink'])
-      realpaths['/mnt/symlink/nonexistant'].stubs(:basename).returns(realpaths['nonexistant'])
-
-      realpaths.each do |path, value|
-        Pathname.stubs(:new).with(path).returns(value)
-      end
-
-      realpath('/mnt/symlink/nonexistant').should == '/mnt/nfs/dest/nonexistant'
+      scratch = Pathname(PuppetSpec::Files.tmpdir('selinux'))
+      selinux_label_support?(scratch + 'nonesuch').should be_true
     end
   end
 

data/spec/unit/util/zaml_spec.rb

@@ -25,12 +25,12 @@ describe "Pure ruby yaml implementation" do
   "-0x123abc"  => '--- "-0x123abc"',
   "-0x123"     => '--- "-0x123"',
   "+0x123"     => '--- "+0x123"',
-  "0x123.456"  => "--- 0x123.456",
+  "0x123.456"  => '--- "0x123.456"',
   'test'       => "--- test",
   []           => "--- []",
   :symbol      => "--- !ruby/sym symbol",
   {:a => "A"}  => "--- \n  !ruby/sym a: A",
-  {:a => "x\ny"} => "--- \n  !ruby/sym a: |-\n    x\n    y" 
+  {:a => "x\ny"} => "--- \n  !ruby/sym a: |-\n    x\n    y"
   }.each { |o,y|
     it "should convert the #{o.class} #{o.inspect} to yaml" do
       o.to_yaml.should == y
@@ -108,6 +108,16 @@ end
 describe "binary data" do
   subject { "M\xC0\xDF\xE5tt\xF6" }
 
+  if String.method_defined?(:encoding)
+    def binary(str)
+      str.force_encoding('binary')
+    end
+  else
+    def binary(str)
+      str
+    end
+  end
+
   it "should not explode encoding binary data" do
     expect { subject.to_yaml }.not_to raise_error
   end
@@ -119,12 +129,90 @@ describe "binary data" do
   it "should round-trip the data" do
     yaml = subject.to_yaml
     read = YAML.load(yaml)
+    binary(read).should == binary(subject)
+  end
 
-    if read.respond_to? :force_encoding
-      read.force_encoding('binary')
-      subject.force_encoding('binary')
+  [
+    "\xC0\xAE",                 # over-long UTF-8 '.' character
+    "\xC0\x80",                 # over-long NULL byte
+    "\xC0\xFF",
+    "\xC1\xAE",
+    "\xC1\x80",
+    "\xC1\xFF",
+    "\x80",                     # first continuation byte
+    "\xbf",                     # last continuation byte
+    # all possible continuation bytes in one shot
+    "\x80\x81\x82\x83\x84\x85\x86\x87\x88\x89\x8A\x8B\x8C\x8D\x8E\x8F" +
+    "\x90\x91\x92\x93\x94\x95\x96\x97\x98\x99\x9A\x9B\x9C\x9D\x9E\x9F" +
+    "\xA0\xA1\xA2\xA3\xA4\xA5\xA6\xA7\xA8\xA9\xAA\xAB\xAC\xAD\xAE\xAF" +
+    "\xB0\xB1\xB2\xB3\xB4\xB5\xB6\xB7\xB8\xB9\xBA\xBB\xBC\xBD\xBE\xBF",
+    # lonely start characters - first, all possible two byte sequences
+    "\xC0 \xC1 \xC2 \xC3 \xC4 \xC5 \xC6 \xC7 \xC8 \xC9 \xCA \xCB \xCC \xCD \xCE \xCF " +
+    "\xD0 \xD1 \xD2 \xD3 \xD4 \xD5 \xD6 \xD7 \xD8 \xD9 \xDA \xDB \xDC \xDD \xDE \xDF ",
+    # and so for three byte sequences, four, five, and six, as follow.
+    "\xE0 \xE1 \xE2 \xE3 \xE4 \xE5 \xE6 \xE7 \xE8 \xE9 \xEA \xEB \xEC \xED \xEE \xEF ",
+    "\xF0 \xF1 \xF2 \xF3 \xF4 \xF5 \xF6 \xF7 ",
+    "\xF8 \xF9 \xFA \xFB ",
+    "\xFC \xFD ",
+    # sequences with the last byte missing
+    "\xC0", "\xE0", "\xF0\x80\x80", "\xF8\x80\x80\x80", "\xFC\x80\x80\x80\x80",
+    "\xDF", "\xEF\xBF", "\xF7\xBF\xBF", "\xFB\xBF\xBF\xBF", "\xFD\xBF\xBF\xBF\xBF",
+    # impossible bytes
+    "\xFE", "\xFF", "\xFE\xFE\xFF\xFF",
+    # over-long '/' character
+    "\xC0\xAF",
+    "\xE0\x80\xAF",
+    "\xF0\x80\x80\xAF",
+    "\xF8\x80\x80\x80\xAF",
+    "\xFC\x80\x80\x80\x80\xAF",
+    # maximum overlong sequences
+    "\xc1\xbf",
+    "\xe0\x9f\xbf",
+    "\xf0\x8f\xbf\xbf",
+    "\xf8\x87\xbf\xbf\xbf",
+    "\xfc\x83\xbf\xbf\xbf\xbf",
+    # overlong NUL
+    "\xc0\x80",
+    "\xe0\x80\x80",
+    "\xf0\x80\x80\x80",
+    "\xf8\x80\x80\x80\x80",
+    "\xfc\x80\x80\x80\x80\x80",
+  ].each do |input|
+    # It might seem like we should more correctly reject these sequences in
+    # the encoder, and I would personally agree, but the sad reality is that
+    # we do not distinguish binary and textual data in our language, and so we
+    # wind up with the same thing - a string - containing both.
+    #
+    # That leads to the position where we must treat these invalid sequences,
+    # which are both legitimate binary content, and illegitimate potential
+    # attacks on the system, as something that passes through correctly in
+    # a string. --daniel 2012-07-14
+    it "binary encode highly dubious non-compliant UTF-8 input #{input.inspect}" do
+      encoded = ZAML.dump(binary(input))
+      encoded.should =~ /!binary/
+      YAML.load(encoded).should == input
     end
+  end
+end
 
-    read.should == subject
+describe "multi-line values" do
+  [
+    "none",
+    "one\n",
+    "two\n\n",
+    ["one\n", "two"],
+    ["two\n\n", "three"],
+    { "\nkey"        => "value" },
+    { "key\n"        => "value" },
+    { "\nkey\n"      => "value" },
+    { "key\nkey"     => "value" },
+    { "\nkey\nkey"   => "value" },
+    { "key\nkey\n"   => "value" },
+    { "\nkey\nkey\n" => "value" },
+  ].each do |input|
+    it "handles #{input.inspect} without corruption" do
+      zaml = ZAML.dump(input)
+      YAML.load(zaml).should == input
+    end
   end
 end