puppet 2.7.13 → 2.7.14

data/spec/unit/type_spec.rb

@@ -611,6 +611,26 @@ describe Puppet::Type, :fails_on_windows => true do
     end
   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
+        newparam(:name) do
+          isnamevar
+        end
+        newproperty(:prop1) do
+        end
+
+        provide(:fake1) do
+          confine :exists => '/no/such/file'
+          mk_resource_methods
+        end
+      end
+
+      expect { fake_type.instances }.should_not raise_error
+    end
+  end
+
+
   describe "::ensurable?" do
     before :each do
       class TestEnsurableType < Puppet::Type

data/spec/unit/util/command_line_spec.rb

@@ -87,7 +87,7 @@ describe Puppet::Util::CommandLine do
     it "should find and invoke an executable with a hyphenated name" do
       commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'], @tty)
       Puppet::Util.expects(:which).with('puppet-whatever').returns('/dev/null/puppet-whatever')
-      commandline.expects(:system).with('/dev/null/puppet-whatever', 'argument')
+      commandline.expects(:exec).with('/dev/null/puppet-whatever', 'argument')
 
       commandline.execute
     end
@@ -96,7 +96,7 @@ describe Puppet::Util::CommandLine do
       it "should abort and show the usage message" do
         commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'], @tty)
         Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
-        commandline.expects(:system).never
+        commandline.expects(:exec).never
 
         expect {
           commandline.execute

data/spec/unit/util/instrumentation/data_spec.rb

@@ -41,4 +41,4 @@ describe Puppet::Util::Instrumentation::Data do
   it "should return a hash containing data when unserializing from pson" do
     Puppet::Util::Instrumentation::Data.from_pson({:name => "name"}).should == {:name => "name"}
   end
-end
+end

data/spec/unit/util/instrumentation/indirection_probe_spec.rb

@@ -16,4 +16,4 @@ describe Puppet::Util::Instrumentation::IndirectionProbe do
     probe = Puppet::Util::Instrumentation::IndirectionProbe.new("probe")
     probe.should set_json_attribute('name').to("probe")
   end
-end
+end

data/spec/unit/util/instrumentation/instrumentable_spec.rb

@@ -183,4 +183,4 @@ describe Puppet::Util::Instrumentation::Instrumentable do
     Puppet::Util::Instrumentation::Instrumentable.enable_probes
     ProbeTest2.new.should respond_to(:instrumented_mymethod)
   end
-end
+end

data/spec/unit/util/instrumentation/listener_spec.rb

@@ -97,4 +97,4 @@ describe Puppet::Util::Instrumentation::Listener do
       Puppet::Util::Instrumentation::Listener.from_pson({"name" => "listener", "enabled" => true})
     end
   end
-end
+end

data/spec/unit/util/instrumentation/listeners/log_spec.rb

@@ -31,4 +31,4 @@ describe log do
     25.times { @log.notify(:test, :stop, { :started => Time.at(123456789), :finished => Time.at(123456790)}) }
     @log.data[:test].size.should == 20
   end
-end
+end

data/spec/unit/util/instrumentation/listeners/performance_spec.rb

@@ -33,4 +33,4 @@ describe performance do
     @performance.notify(:test, :start, { :started => Time.at(123456789)})
     @performance.data.should be_empty
   end
-end
+end

data/spec/unit/util/instrumentation_spec.rb

@@ -178,4 +178,4 @@ describe Puppet::Util::Instrumentation do
       end
     end
   end
-end
+end

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

@@ -29,8 +29,8 @@ describe Puppet::Util::Log.desttypes[:file] do
     @class = Puppet::Util::Log.desttypes[:file]
   end
 
-  it "should default to autoflush false" do
-    @class.new('/tmp/log').autoflush.should == false
+  it "should default to automatically flush log output" do
+    @class.new('/tmp/log').autoflush.should == true
   end
 
   describe "when matching" do
@@ -44,18 +44,14 @@ describe Puppet::Util::Log.desttypes[:file] do
       end
     end
 
-    describe "on POSIX systems" do
-      before :each do Puppet.features.stubs(:microsoft_windows?).returns false end
-
+    describe "on POSIX systems", :as_platform => :posix do
       let (:abspath) { '/tmp/log' }
       let (:relpath) { 'log' }
 
       it_behaves_like "file destination"
     end
 
-    describe "on Windows systems" do
-      before :each do Puppet.features.stubs(:microsoft_windows?).returns true end
-
+    describe "on Windows systems", :as_platform => :windows do
       let (:abspath) { 'C:\\temp\\log.txt' }
       let (:relpath) { 'log.txt' }
 

data/spec/unit/util/log_spec.rb

@@ -22,8 +22,17 @@ describe Puppet::Util::Log do
       Puppet::Util::Log.setup_default
     end
 
+    it "should fall back to :eventlog" do
+      Puppet.features.stubs(:syslog?).returns(false)
+      Puppet.features.stubs(:eventlog?).returns(true)
+      Puppet::Util::Log.expects(:newdestination).with(:eventlog)
+
+      Puppet::Util::Log.setup_default
+    end
+
     it "should fall back to :file" do
       Puppet.features.stubs(:syslog?).returns(false)
+      Puppet.features.stubs(:eventlog?).returns(false)
       Puppet::Util::Log.expects(:newdestination).with(Puppet[:puppetdlog])
 
       Puppet::Util::Log.setup_default
@@ -72,6 +81,44 @@ describe Puppet::Util::Log do
     end
   end
 
+  describe Puppet::Util::Log::DestEventlog, :if => Puppet.features.eventlog? do
+    before :each do
+      Win32::EventLog.stubs(:open).returns(mock 'mylog')
+      Win32::EventLog.stubs(:report_event)
+      Win32::EventLog.stubs(:close)
+      Puppet.features.stubs(:eventlog?).returns(true)
+    end
+
+    it "should restrict its suitability" do
+      Puppet.features.expects(:eventlog?).returns(false)
+
+      Puppet::Util::Log::DestEventlog.suitable?('whatever').should == false
+    end
+
+    it "should open the 'Application' event log" do
+      Win32::EventLog.expects(:open).with('Application')
+
+      Puppet::Util::Log.newdestination(:eventlog)
+    end
+
+    it "should close the event log" do
+      log = mock('myeventlog')
+      log.expects(:close)
+      Win32::EventLog.expects(:open).returns(log)
+
+      Puppet::Util::Log.newdestination(:eventlog)
+      Puppet::Util::Log.close(:eventlog)
+    end
+
+    it "should handle each puppet log level" do
+      log = Puppet::Util::Log::DestEventlog.new
+
+      Puppet::Util::Log.eachlevel do |level|
+        log.to_native(level).should be_is_a(Array)
+      end
+    end
+  end
+
   describe "instances" do
     before do
       Puppet::Util::Log.stubs(:newmessage)

data/spec/unit/util/reference_spec.rb

@@ -36,4 +36,4 @@ A term
     EOT
   end
 
-end
+end

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

@@ -286,5 +286,14 @@ describe Puppet::Util::Settings::FileSetting do
       @file.to_resource[:links].should == :follow
     end
   end
+
+  describe "when munging a filename" do
+    it "should preserve trailing slashes" do
+      settings = mock 'settings'
+      file = Puppet::Util::Settings::FileSetting.new(:settings => settings, :desc => "eh", :name => :mydir, :section => "mysect")
+      path = @basepath + '/'
+      file.munge(path).should == path
+    end
+  end
 end
 

data/spec/unit/util/settings_spec.rb

@@ -411,13 +411,6 @@ describe Puppet::Util::Settings do
       @settings.parse
     end
 
-    it "should set a timer that triggers reparsing, even if the file does not exist" do
-      FileTest.expects(:exist?).returns false
-      @settings.expects(:set_filetimeout_timer)
-
-      @settings.parse
-    end
-
     it "should return values set in the configuration file" do
       text = "[main]
       one = fileval
@@ -559,12 +552,6 @@ describe Puppet::Util::Settings do
         File.expects(:expand_path).with(somefile).returns somefile
         @settings[:config] = somefile
       end
-
-      it "should not set a timer" do
-        EventLoop::Timer.expects(:new).never
-
-        @settings.parse
-      end
     end
   end
 
@@ -1057,46 +1044,6 @@ describe Puppet::Util::Settings do
     end
   end
 
-  describe "when setting a timer to trigger configuration file reparsing" do
-    before do
-      @settings = Puppet::Util::Settings.new
-      @settings.setdefaults :foo, :filetimeout => [5, "eh"]
-    end
-
-    it "should do nothing if no filetimeout setting is available" do
-      @settings.expects(:value).with(:filetimeout).returns nil
-      EventLoop::Timer.expects(:new).never
-      @settings.set_filetimeout_timer
-    end
-
-    it "should always convert the timer interval to an integer" do
-      @settings.expects(:value).with(:filetimeout).returns "10"
-      EventLoop::Timer.expects(:new).with(:interval => 10, :start? => true, :tolerance => 1)
-      @settings.set_filetimeout_timer
-    end
-
-    it "should do nothing if the filetimeout setting is not greater than 0" do
-      @settings.expects(:value).with(:filetimeout).returns -2
-      EventLoop::Timer.expects(:new).never
-      @settings.set_filetimeout_timer
-    end
-
-    it "should create a timer with its interval set to the filetimeout, start? set to true, and a tolerance of 1" do
-      @settings.expects(:value).with(:filetimeout).returns 5
-      EventLoop::Timer.expects(:new).with(:interval => 5, :start? => true, :tolerance => 1)
-
-      @settings.set_filetimeout_timer
-    end
-
-    it "should reparse when the timer goes off" do
-      EventLoop::Timer.expects(:new).with(:interval => 5, :start? => true, :tolerance => 1).yields
-
-      @settings.expects(:reparse)
-
-      @settings.set_filetimeout_timer
-    end
-  end
-
   describe "when determining if the service user is available" do
     it "should return false if there is no user setting" do
       Puppet::Util::Settings.new.should_not be_service_user_available

data/spec/unit/util/terminal_spec.rb

@@ -0,0 +1,42 @@
+#!/usr/bin/env rspec
+require 'spec_helper'
+require 'puppet/util/terminal'
+
+describe Puppet::Util::Terminal do
+  describe '.width' do
+    before { Puppet.features.stubs(:posix?).returns(true) }
+
+    it 'should invoke `stty` and return the width' do
+      height, width = 100, 200
+      subject.expects(:`).with('stty size 2>/dev/null').returns("#{height} #{width}\n")
+      subject.width.should == width
+    end
+
+    it 'should use `tput` if `stty` is unavailable' do
+      width = 200
+      subject.expects(:`).with('stty size 2>/dev/null').returns("\n")
+      subject.expects(:`).with('tput cols 2>/dev/null').returns("#{width}\n")
+      subject.width.should == width
+    end
+
+    it 'should default to 80 columns if `tput` and `stty` are unavailable' do
+      width = 80
+      subject.expects(:`).with('stty size 2>/dev/null').returns("\n")
+      subject.expects(:`).with('tput cols 2>/dev/null').returns("\n")
+      subject.width.should == width
+    end
+
+    it 'should default to 80 columns if `tput` or `stty` raise exceptions' do
+      width = 80
+      subject.expects(:`).with('stty size 2>/dev/null').raises()
+      subject.stubs(:`).with('tput cols 2>/dev/null').returns("#{width + 1000}\n")
+      subject.width.should == width
+    end
+
+    it 'should default to 80 columns if not in a POSIX environment' do
+      width = 80
+      Puppet.features.stubs(:posix?).returns(false)
+      subject.width.should == width
+    end
+  end
+end

data/spec/unit/util/zaml_spec.rb

@@ -19,6 +19,13 @@ describe "Pure ruby yaml implementation" do
   {
   7            => "--- 7",
   3.14159      => "--- 3.14159",
+  "3.14159"    => '--- "3.14159"',
+  "+3.14159"   => '--- "+3.14159"',
+  "0x123abc"   => '--- "0x123abc"',
+  "-0x123abc"  => '--- "-0x123abc"',
+  "-0x123"     => '--- "-0x123"',
+  "+0x123"     => '--- "+0x123"',
+  "0x123.456"  => "--- 0x123.456",
   'test'       => "--- test",
   []           => "--- []",
   :symbol      => "--- !ruby/sym symbol",

data/spec/unit/util_spec.rb

@@ -30,18 +30,18 @@ describe Puppet::Util do
   end
 
   describe "#absolute_path?" do
-    it "should default to the platform of the local system" do
-      Puppet.features.stubs(:posix?).returns(true)
-      Puppet.features.stubs(:microsoft_windows?).returns(false)
-
-      Puppet::Util.should be_absolute_path('/foo')
-      Puppet::Util.should_not be_absolute_path('C:/foo')
-
-      Puppet.features.stubs(:posix?).returns(false)
-      Puppet.features.stubs(:microsoft_windows?).returns(true)
+    describe "on posix systems", :as_platform => :posix do
+      it "should default to the platform of the local system" do
+        Puppet::Util.should be_absolute_path('/foo')
+        Puppet::Util.should_not be_absolute_path('C:/foo')
+      end
+    end
 
-      Puppet::Util.should be_absolute_path('C:/foo')
-      Puppet::Util.should_not be_absolute_path('/foo')
+    describe "on windows", :as_platform => :windows do
+      it "should default to the platform of the local system" do
+        Puppet::Util.should be_absolute_path('C:/foo')
+        Puppet::Util.should_not be_absolute_path('/foo')
+      end
     end
 
     describe "when using platform :posix" do
@@ -223,15 +223,6 @@ describe Puppet::Util do
         Puppet::Util.execute_posix('test command', {}, @stdin, @stdout, @stderr)
       end
 
-      it "should close all open file descriptors except stdin/stdout/stderr" do
-        # This is ugly, but I can't really think of a better way to do it without
-        # letting it actually close fds, which seems risky
-        (0..2).each {|n| IO.expects(:new).with(n).never}
-        (3..256).each {|n| IO.expects(:new).with(n).returns mock('io', :close) }
-
-        Puppet::Util.execute_posix('test command', {}, @stdin, @stdout, @stderr)
-      end
-
       it "should permanently change to the correct user and group if specified" do
         Puppet::Util::SUIDManager.expects(:change_group).with(55, true)
         Puppet::Util::SUIDManager.expects(:change_user).with(50, true)
@@ -487,6 +478,38 @@ describe Puppet::Util do
         }.not_to raise_error
       end
     end
+
+    describe "safe_posix_fork" do
+      before :each do
+        # Most of the things this method does are bad to do during specs. :/
+        Kernel.stubs(:fork).returns(pid).yields
+
+        $stdin.stubs(:reopen)
+        $stdout.stubs(:reopen)
+        $stderr.stubs(:reopen)
+      end
+
+      it "should close all open file descriptors except stdin/stdout/stderr" do
+        # This is ugly, but I can't really think of a better way to do it without
+        # letting it actually close fds, which seems risky
+        (0..2).each {|n| IO.expects(:new).with(n).never}
+        (3..256).each {|n| IO.expects(:new).with(n).returns mock('io', :close) }
+
+        Puppet::Util.safe_posix_fork
+      end
+
+      it "should fork a child process to execute the block" do
+        Kernel.expects(:fork).returns(pid).yields
+
+        Puppet::Util.safe_posix_fork do
+          message = "Fork this!"
+        end
+      end
+
+      it "should return the pid of the child process" do
+        Puppet::Util.safe_posix_fork.should == pid
+      end
+    end
   end
 
   describe "#execpipe" do
@@ -637,6 +660,26 @@ describe Puppet::Util do
     end
   end
 
+  describe "hash symbolizing functions" do
+    let (:myhash) { { "foo" => "bar", :baz => "bam" } }
+    let (:resulthash) { { :foo => "bar", :baz => "bam" } }
+
+    describe "#symbolizehash" do
+      it "should return a symbolized hash" do
+        newhash = Puppet::Util.symbolizehash(myhash)
+        newhash.should == resulthash
+      end
+    end
+
+    describe "#symbolizehash!" do
+      it "should symbolize the hash in place" do
+        localhash = myhash
+        Puppet::Util.symbolizehash!(localhash)
+        localhash.should == resulthash
+      end
+    end
+  end
+
   context "#replace_file" do
     describe "on POSIX platforms", :if => Puppet.features.posix? do
       subject { Puppet::Util }