puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

data/spec/unit/util/feature_spec.rb

@@ -91,4 +91,16 @@ describe Puppet::Util::Feature do
     @features.should_not be_myfeature
     @features.should be_myfeature
   end
+
+  it "should cache load failures when configured to do so" do
+    Puppet[:always_cache_features] = true
+
+    @features.add(:myfeature, :libs => %w{foo bar})
+    @features.expects(:require).with("foo").raises(LoadError)
+
+    @features.should_not be_myfeature
+    # second call would cause an expectation exception if 'require' was
+    # called a second time
+    @features.should_not be_myfeature
+  end
 end

data/spec/unit/util/http_proxy_spec.rb

@@ -4,7 +4,7 @@ require 'puppet/util/http_proxy'
 
 describe Puppet::Util::HttpProxy do
 
-  host, port = 'some.host', 1234
+  host, port, user, password = 'some.host', 1234, 'user1', 'pAssw0rd'
 
   describe ".http_proxy_env" do
     it "should return nil if no environment variables" do
@@ -80,4 +80,46 @@ describe Puppet::Util::HttpProxy do
 
   end
 
+  describe ".http_proxy_user" do
+    it "should return a proxy user if set in environment" do
+      Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
+        subject.http_proxy_user.should == user
+      end
+    end
+
+    it "should return a proxy user if set in config" do
+      Puppet.settings[:http_proxy_user] = user
+      subject.http_proxy_user.should == user
+    end
+
+    it "should use environment variable before puppet settings" do
+      Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
+        Puppet.settings[:http_proxy_user] = 'clownpants'
+        subject.http_proxy_user.should == user
+      end
+    end
+
+  end
+
+  describe ".http_proxy_password" do
+    it "should return a proxy password if set in environment" do
+      Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
+        subject.http_proxy_password.should == password
+      end
+    end
+
+    it "should return a proxy password if set in config" do
+      Puppet.settings[:http_proxy_user] = user
+      Puppet.settings[:http_proxy_password] = password
+      subject.http_proxy_password.should == password
+    end
+
+    it "should use environment variable before puppet settings" do
+      Puppet::Util.withenv('HTTP_PROXY' => "http://#{user}:#{password}@#{host}:#{port}") do
+        Puppet.settings[:http_proxy_password] = 'clownpants'
+        subject.http_proxy_password.should == password
+      end
+    end
+
+  end
 end

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

@@ -29,7 +29,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 
+    File.stubs(:chown)          # prevent chown on non existing file from failing
     @class = Puppet::Util::Log.desttypes[:file]
   end
 
@@ -181,3 +181,47 @@ describe Puppet::Util::Log.desttypes[:console] do
     end
   end
 end
+
+
+describe ":eventlog", :if => Puppet::Util::Platform.windows? do
+  before do
+    if Facter.value(:kernelmajversion).to_f < 6.0
+      pending("requires win32-eventlog gem upgrade to 0.6.2 on Windows 2003")
+    end
+  end
+
+  let(:klass) { Puppet::Util::Log.desttypes[:eventlog] }
+
+  def expects_message_with_type(klass, level, eventlog_type, eventlog_id)
+    eventlog = stub('eventlog')
+    eventlog.expects(:report_event).with(has_entries(:source => "Puppet", :event_type => eventlog_type, :event_id => eventlog_id, :data => "a hitchhiker: don't panic"))
+    Win32::EventLog.stubs(:open).returns(eventlog)
+
+    msg = Puppet::Util::Log.new(:level => level, :message => "don't panic", :source => "a hitchhiker")
+    dest = klass.new
+    dest.handle(msg)
+  end
+
+  it "supports the eventlog feature" do
+    expect(Puppet.features.eventlog?).to be_true
+  end
+
+  it "logs to the Application event log" do
+    eventlog = stub('eventlog')
+    Win32::EventLog.expects(:open).with('Application').returns(stub('eventlog'))
+
+    klass.new
+  end
+
+  it "logs :debug level as an information type event" do
+    expects_message_with_type(klass, :debug, klass::EVENTLOG_INFORMATION_TYPE, 0x1)
+  end
+
+  it "logs :warning level as an warning type event" do
+    expects_message_with_type(klass, :warning, klass::EVENTLOG_WARNING_TYPE, 0x2)
+  end
+
+  it "logs :err level as an error type event" do
+    expects_message_with_type(klass, :err, klass::EVENTLOG_ERROR_TYPE, 0x3)
+  end
+end

data/spec/unit/util/logging_spec.rb

@@ -139,6 +139,44 @@ describe Puppet::Util::Logging do
     end
   end
 
+  describe "when sending a puppet_deprecation_warning" do
+    it "requires file and line or key options" do
+      expect do
+        @logger.puppet_deprecation_warning("foo")
+      end.to raise_error(Puppet::DevError, /Need either :file and :line, or :key/)
+      expect do
+        @logger.puppet_deprecation_warning("foo", :file => 'bar')
+      end.to raise_error(Puppet::DevError, /Need either :file and :line, or :key/)
+      expect do
+        @logger.puppet_deprecation_warning("foo", :key => 'akey')
+        @logger.puppet_deprecation_warning("foo", :file => 'afile', :line => 1)
+      end.to_not raise_error
+    end
+
+    it "warns with file and line" do
+      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*afile:5/m))
+      @logger.puppet_deprecation_warning("deprecated foo", :file => 'afile', :line => 5)
+    end
+
+    it "warns keyed from file and line" do
+      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*afile:5/m)).once
+      5.times do
+        @logger.puppet_deprecation_warning("deprecated foo", :file => 'afile', :line => 5)
+      end
+    end
+
+    it "warns with separate key only once regardless of file and line" do
+      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*afile:5/m)).once
+      @logger.puppet_deprecation_warning("deprecated foo", :key => 'some_key', :file => 'afile', :line => 5)
+      @logger.puppet_deprecation_warning("deprecated foo", :key => 'some_key', :file => 'bfile', :line => 3)
+    end
+
+    it "warns with key but no file and line" do
+      @logger.expects(:warning).with(regexp_matches(/deprecated foo.*unknown:unknown/m))
+      @logger.puppet_deprecation_warning("deprecated foo", :key => 'some_key')
+    end
+  end
+
   describe "when formatting exceptions" do
     it "should be able to format a chain of exceptions" do
       exc3 = Puppet::Error.new("original")

data/spec/unit/util/pidlock_spec.rb

@@ -50,6 +50,26 @@ describe Puppet::Util::Pidlock do
       Puppet::FileSystem.exist?(@lockfile).should be_true
     end
 
+    it 'should create an empty lock file even when pid is missing' do
+      Process.stubs(:pid).returns('')
+      @lock.lock
+      Puppet::FileSystem.exist?(@lock.file_path).should be_true
+      Puppet::FileSystem.read(@lock.file_path).should be_empty
+    end
+
+    it 'should replace an existing empty lockfile with a pid, given a subsequent lock call made against a valid pid' do
+      # empty pid results in empty lockfile
+      Process.stubs(:pid).returns('')
+      @lock.lock
+      Puppet::FileSystem.exist?(@lock.file_path).should be_true
+
+      # next lock call with valid pid kills existing empty lockfile
+      Process.stubs(:pid).returns(1234)
+      @lock.lock
+      Puppet::FileSystem.exist?(@lock.file_path).should be_true
+      Puppet::FileSystem.read(@lock.file_path).should == '1234'
+    end
+
     it "should expose the lock file_path" do
       @lock.file_path.should == @lockfile
     end
@@ -83,6 +103,22 @@ describe Puppet::Util::Pidlock do
       @lock.lock
       @lock.should be_locked
     end
+
+    it "should remove the lockfile when pid is missing" do
+      Process.stubs(:pid).returns('')
+      @lock.lock
+      @lock.locked?.should be_false
+      Puppet::FileSystem.exist?(@lock.file_path).should be_false
+    end
+  end
+
+  describe '#lock_pid' do
+    it 'should return nil if the pid is empty' do
+      # fake pid to get empty lockfile
+      Process.stubs(:pid).returns('')
+      @lock.lock
+      @lock.lock_pid.should == nil
+    end
   end
 
   describe "with a stale lock" do
@@ -105,7 +141,7 @@ describe Puppet::Util::Pidlock do
 
     describe "#lock" do
       it "should clear stale locks" do
-        @lock.locked?
+        @lock.locked?.should be_false
         Puppet::FileSystem.exist?(@lockfile).should be_false
       end
 

data/spec/unit/util/profiler/aggregate_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+require 'puppet/util/profiler'
+require 'puppet/util/profiler/around_profiler'
+require 'puppet/util/profiler/aggregate'
+
+describe Puppet::Util::Profiler::Aggregate do
+  let(:logger) { AggregateSimpleLog.new }
+  let(:profiler) { Puppet::Util::Profiler::Aggregate.new(logger, nil) }
+  let(:profiler_mgr) do
+    p = Puppet::Util::Profiler::AroundProfiler.new
+    p.add_profiler(profiler)
+    p
+  end
+
+  it "tracks the aggregate counts and time for the hierarchy of metrics" do
+    profiler_mgr.profile("Looking up hiera data in production environment", ["function", "hiera_lookup", "production"]) { sleep 0.01 }
+    profiler_mgr.profile("Looking up hiera data in test environment", ["function", "hiera_lookup", "test"]) {}
+    profiler_mgr.profile("looking up stuff for compilation", ["compiler", "lookup"]) { sleep 0.01 }
+    profiler_mgr.profile("COMPILING ALL OF THE THINGS!", ["compiler", "compiling"]) {}
+
+    profiler.values["function"].count.should == 2
+    profiler.values["function"].time.should be > 0
+    profiler.values["function"]["hiera_lookup"].count.should == 2
+    profiler.values["function"]["hiera_lookup"]["production"].count.should == 1
+    profiler.values["function"]["hiera_lookup"]["test"].count.should == 1
+    profiler.values["function"].time.should be >= profiler.values["function"]["hiera_lookup"]["test"].time
+
+    profiler.values["compiler"].count.should == 2
+    profiler.values["compiler"].time.should be > 0
+    profiler.values["compiler"]["lookup"].count.should == 1
+    profiler.values["compiler"]["compiling"].count.should == 1
+    profiler.values["compiler"].time.should be >= profiler.values["compiler"]["lookup"].time
+
+    profiler.shutdown
+
+    logger.output.should =~ /function -> hiera_lookup: .*\(2 calls\)\nfunction -> hiera_lookup ->.*\(1 calls\)/
+    logger.output.should =~ /compiler: .*\(2 calls\)\ncompiler ->.*\(1 calls\)/
+  end
+
+  it "tolerates calls to `profile` that don't include a metric id" do
+    profiler_mgr.profile("yo") {}
+  end
+
+  it "supports both symbols and strings as components of a metric id" do
+    profiler_mgr.profile("yo", [:foo, "bar"]) {}
+  end
+
+  class AggregateSimpleLog
+    attr_reader :output
+
+    def initialize
+      @output = ""
+    end
+
+    def call(msg)
+      @output << msg << "\n"
+    end
+  end
+end

data/spec/unit/util/profiler/around_profiler_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'puppet/util/profiler'
+
+describe Puppet::Util::Profiler::AroundProfiler do
+  let(:child) { TestAroundProfiler.new() }
+  let(:profiler) { Puppet::Util::Profiler::AroundProfiler.new }
+
+  before :each do
+    profiler.add_profiler(child)
+  end
+
+  it "returns the value of the profiled segment" do
+    retval = profiler.profile("Testing", ["testing"]) { "the return value" }
+
+    retval.should == "the return value"
+  end
+
+  it "propagates any errors raised in the profiled segment" do
+    expect do
+      profiler.profile("Testing", ["testing"]) { raise "a problem" }
+    end.to raise_error("a problem")
+  end
+
+  it "makes the description and the context available to the `start` and `finish` methods" do
+    profiler.profile("Testing", ["testing"]) { }
+
+    child.context.should == "Testing"
+    child.description.should == "Testing"
+  end
+
+  it "calls finish even when an error is raised" do
+    begin
+      profiler.profile("Testing", ["testing"]) { raise "a problem" }
+    rescue
+      child.context.should == "Testing"
+    end
+  end
+
+  it "supports multiple profilers" do
+    profiler2 = TestAroundProfiler.new
+    profiler.add_profiler(profiler2)
+    profiler.profile("Testing", ["testing"]) {}
+
+    child.context.should == "Testing"
+    profiler2.context.should == "Testing"
+  end
+
+  class TestAroundProfiler
+    attr_accessor :context, :description
+
+    def start(description, metric_id)
+      description
+    end
+
+    def finish(context, description, metric_id)
+      @context = context
+      @description = description
+    end
+  end
+end
+

data/spec/unit/util/profiler/logging_spec.rb

@@ -4,51 +4,40 @@ require 'puppet/util/profiler'
 describe Puppet::Util::Profiler::Logging do
   let(:logger) { SimpleLog.new }
   let(:identifier) { "Profiling ID" }
-  let(:profiler) { TestLoggingProfiler.new(logger, identifier) }
-
-  it "returns the value of the profiled segment" do
-    retval = profiler.profile("Testing") { "the return value" }
-
-    retval.should == "the return value"
-  end
-
-  it "propogates any errors raised in the profiled segment" do
-    expect do
-      profiler.profile("Testing") { raise "a problem" }
-    end.to raise_error("a problem")
+  let(:logging_profiler) { TestLoggingProfiler.new(logger, identifier) }
+  let(:profiler) do
+    p = Puppet::Util::Profiler::AroundProfiler.new
+    p.add_profiler(logging_profiler)
+    p
   end
 
   it "logs the explanation of the profile results" do
-    profiler.profile("Testing") { }
+    profiler.profile("Testing", ["test"]) { }
 
     logger.messages.first.should =~ /the explanation/
   end
 
-  it "logs results even when an error is raised" do
-    begin
-      profiler.profile("Testing") { raise "a problem" }
-    rescue
-      logger.messages.first.should =~ /the explanation/
-    end
-  end
-
   it "describes the profiled segment" do
-    profiler.profile("Tested measurement") { }
+    profiler.profile("Tested measurement", ["test"]) { }
 
     logger.messages.first.should =~ /PROFILE \[#{identifier}\] \d Tested measurement/
   end
 
   it "indicates the order in which segments are profiled" do
-    profiler.profile("Measurement") { }
-    profiler.profile("Another measurement") { }
+    profiler.profile("Measurement", ["measurement"]) { }
+    profiler.profile("Another measurement", ["measurement"]) { }
 
     logger.messages[0].should =~ /1 Measurement/
     logger.messages[1].should =~ /2 Another measurement/
   end
 
   it "indicates the nesting of profiled segments" do
-    profiler.profile("Measurement") { profiler.profile("Nested measurement") { } }
-    profiler.profile("Another measurement") { profiler.profile("Another nested measurement") { } }
+    profiler.profile("Measurement", ["measurement1"]) do
+      profiler.profile("Nested measurement", ["measurement2"]) { }
+    end
+    profiler.profile("Another measurement", ["measurement1"]) do
+      profiler.profile("Another nested measurement", ["measurement2"]) { }
+    end
 
     logger.messages[0].should =~ /1.1 Nested measurement/
     logger.messages[1].should =~ /1 Measurement/
@@ -57,12 +46,12 @@ describe Puppet::Util::Profiler::Logging do
   end
 
   class TestLoggingProfiler < Puppet::Util::Profiler::Logging
-    def start
+    def do_start(metric, description)
       "the start"
     end
 
-    def finish(context)
-      "the explanation of #{context}"
+    def do_finish(context, metric, description)
+      {:msg => "the explanation of #{context}"}
     end
   end
 

data/spec/unit/util/profiler/wall_clock_spec.rb

@@ -6,7 +6,7 @@ describe Puppet::Util::Profiler::WallClock do
   it "logs the number of seconds it took to execute the segment" do
     profiler = Puppet::Util::Profiler::WallClock.new(nil, nil)
 
-    message = profiler.finish(profiler.start)
+    message = profiler.do_finish(profiler.start(["foo", "bar"], "Testing"), ["foo", "bar"], "Testing")[:msg]
 
     message.should =~ /took \d\.\d{4} seconds/
   end