puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/util/backups_spec.rb

@@ -35,7 +35,7 @@ describe Puppet::Util::Backups do
     end
 
     it "a bucket should be used when provided" do
-      File.stubs(:stat).with(path).returns(mock('stat', :ftype => 'file'))
+      File.stubs(:lstat).with(path).returns(mock('lstat', :ftype => 'file'))
       bucket.expects(:backup).with(path).returns("mysum")
       FileTest.expects(:exists?).with(path).returns(true)
 
@@ -43,7 +43,7 @@ describe Puppet::Util::Backups do
     end
 
     it "should propagate any exceptions encountered when backing up to a filebucket" do
-      File.stubs(:stat).with(path).returns(mock('stat', :ftype => 'file'))
+      File.stubs(:lstat).with(path).returns(mock('lstat', :ftype => 'file'))
       bucket.expects(:backup).raises ArgumentError
       FileTest.expects(:exists?).with(path).returns(true)
 
@@ -108,7 +108,7 @@ describe Puppet::Util::Backups do
 
       bucket.expects(:backup).with(filename).returns true
 
-      File.stubs(:stat).with(path).returns(stub('stat', :ftype => 'directory'))
+      File.stubs(:lstat).with(path).returns(stub('lstat', :ftype => 'directory'))
 
       FileTest.stubs(:exists?).with(path).returns(true)
       FileTest.stubs(:exists?).with(filename).returns(true)

data/spec/unit/util/http_proxy_spec.rb

@@ -0,0 +1,83 @@
+require 'uri'
+require 'spec_helper'
+require 'puppet/util/http_proxy'
+
+describe Puppet::Util::HttpProxy do
+
+  host, port = 'some.host', 1234
+
+  describe ".http_proxy_env" do
+    it "should return nil if no environment variables" do
+      subject.http_proxy_env.should == nil
+    end
+
+    it "should return a URI::HTTP object if http_proxy env variable is set" do
+      Puppet::Util.withenv('HTTP_PROXY' => host) do
+        subject.http_proxy_env.should == URI.parse(host)
+      end
+    end
+
+    it "should return a URI::HTTP object if HTTP_PROXY env variable is set" do
+      Puppet::Util.withenv('HTTP_PROXY' => host) do
+        subject.http_proxy_env.should == URI.parse(host)
+      end
+    end
+
+    it "should return a URI::HTTP object with .host and .port if URI is given" do
+      Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
+        subject.http_proxy_env.should == URI.parse("http://#{host}:#{port}")
+      end
+    end
+
+    it "should return nil if proxy variable is malformed" do
+      Puppet::Util.withenv('HTTP_PROXY' => 'this is not a valid URI') do
+        subject.http_proxy_env.should == nil
+      end
+    end
+  end
+
+  describe ".http_proxy_host" do
+    it "should return nil if no proxy host in config or env" do
+      subject.http_proxy_host.should == nil
+    end
+
+    it "should return a proxy host if set in config" do
+      Puppet.settings[:http_proxy_host] = host
+      subject.http_proxy_host.should == host
+    end
+
+    it "should return nil if set to `none` in config" do
+      Puppet.settings[:http_proxy_host] = 'none'
+      subject.http_proxy_host.should == nil
+    end
+
+    it "uses environment variable before puppet settings" do
+      Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
+        Puppet.settings[:http_proxy_host] = 'not.correct'
+        subject.http_proxy_host.should == host
+      end
+    end
+  end
+
+  describe ".http_proxy_port" do
+    it "should return a proxy port if set in environment" do
+      Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
+        subject.http_proxy_port.should == port
+      end
+    end
+
+    it "should return a proxy port if set in config" do
+      Puppet.settings[:http_proxy_port] = port
+      subject.http_proxy_port.should == port
+    end
+
+    it "uses environment variable before puppet settings" do
+      Puppet::Util.withenv('HTTP_PROXY' => "http://#{host}:#{port}") do
+        Puppet.settings[:http_proxy_port] = 7456
+        subject.http_proxy_port.should == port
+      end
+    end
+
+  end
+
+end

data/spec/unit/util/log_spec.rb

@@ -6,6 +6,10 @@ require 'puppet/util/log'
 describe Puppet::Util::Log do
   include PuppetSpec::Files
 
+  def log_notice(message)
+    Puppet::Util::Log.new(:level => :notice, :message => message)
+  end
+
   it "should write a given message to the specified destination" do
     arraydest = []
     Puppet::Util::Log.newdestination(Puppet::Test::LogCollector.new(arraydest))
@@ -39,6 +43,57 @@ describe Puppet::Util::Log do
     end
   end
 
+  describe "#with_destination" do
+    it "does nothing when nested" do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+      Puppet::Util::Log.with_destination(destination) do
+        Puppet::Util::Log.with_destination(destination) do
+          log_notice("Inner block")
+        end
+
+        log_notice("Outer block")
+      end
+
+      log_notice("Outside")
+
+      expect(logs.collect(&:message)).to include("Inner block", "Outer block")
+      expect(logs.collect(&:message)).not_to include("Outside")
+    end
+
+    it "logs when called a second time" do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.with_destination(destination) do
+        log_notice("First block")
+      end
+
+      log_notice("Between blocks")
+
+      Puppet::Util::Log.with_destination(destination) do
+        log_notice("Second block")
+      end
+
+      expect(logs.collect(&:message)).to include("First block", "Second block")
+      expect(logs.collect(&:message)).not_to include("Between blocks")
+    end
+
+    it "doesn't close the destination if already set manually" do
+      logs = []
+      destination = Puppet::Test::LogCollector.new(logs)
+
+      Puppet::Util::Log.newdestination(destination)
+      Puppet::Util::Log.with_destination(destination) do
+        log_notice "Inner block"
+      end
+
+      log_notice "Outer block"
+      Puppet::Util::Log.close(destination)
+
+      expect(logs.collect(&:message)).to include("Inner block", "Outer block")
+    end
+  end
   describe Puppet::Util::Log::DestConsole do
     before do
       @console = Puppet::Util::Log::DestConsole.new
@@ -186,7 +241,7 @@ describe Puppet::Util::Log do
       log.tags.should be_include("bar")
     end
 
-    it "should use an passed-in source" do
+    it "should use a passed-in source" do
       Puppet::Util::Log.any_instance.expects(:source=).with "foo"
       Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => "foo")
     end
@@ -247,34 +302,37 @@ describe Puppet::Util::Log do
     end
 
     describe "when setting the source as a RAL object" do
+      let(:path) { File.expand_path('/foo/bar') }
+
       it "should tag itself with any tags the source has" do
-        source = Puppet::Type.type(:file).new :path => make_absolute("/foo/bar")
+        source = Puppet::Type.type(:file).new :path => path
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
         source.tags.each do |tag|
           log.tags.should be_include(tag)
         end
       end
 
-      it "should use the source_descriptors" do
-        source = stub "source"
-        source.stubs(:source_descriptors).returns(:tags => ["tag","tag2"], :path => "path", :version => 100)
+      it "should set the source to 'path', when available" do
+        source = Puppet::Type.type(:file).new :path => path
+        source.tags = ["tag", "tag2"]
 
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo)
+        log.expects(:tag).with("file")
         log.expects(:tag).with("tag")
         log.expects(:tag).with("tag2")
 
         log.source = source
 
-        log.source.should == "path"
+        log.source.should == "/File[#{path}]"
       end
 
       it "should copy over any file and line information" do
-        source = Puppet::Type.type(:file).new :path => make_absolute("/foo/bar")
+        source = Puppet::Type.type(:file).new :path => path
         source.file = "/my/file"
         source.line = 50
         log = Puppet::Util::Log.new(:level => "notice", :message => :foo, :source => source)
-        log.file.should == "/my/file"
         log.line.should == 50
+        log.file.should == "/my/file"
       end
     end
 
@@ -304,4 +362,17 @@ describe Puppet::Util::Log do
       log.to_yaml_properties.should include(:@line)
     end
   end
+
+  it "should round trip through pson" do
+    log = Puppet::Util::Log.new(:level => 'notice', :message => 'hooray', :file => 'thefile', :line => 1729, :source => 'specs', :tags => ['a', 'b', 'c'])
+    tripped = Puppet::Util::Log.from_pson(PSON.parse(log.to_pson))
+
+    tripped.file.should == log.file
+    tripped.line.should == log.line
+    tripped.level.should == log.level
+    tripped.message.should == log.message
+    tripped.source.should == log.source
+    tripped.tags.should == log.tags
+    tripped.time.should == log.time
+  end
 end

data/spec/unit/util/metric_spec.rb

@@ -83,4 +83,16 @@ describe Puppet::Util::Metric do
   it "should return nil if the named value cannot be found" do
     @metric["foo"].should == 0
   end
+
+  it "should round trip through pson" do
+    metric = Puppet::Util::Metric.new("foo", "mylabel")
+    metric.newvalue("v1", 10.1, "something")
+    metric.newvalue("v2", 20, "something else")
+
+    tripped = Puppet::Util::Metric.from_pson(PSON.parse(metric.to_pson))
+
+    tripped.name.should == metric.name
+    tripped.label.should == metric.label
+    tripped.values.should == metric.values
+  end
 end

data/spec/unit/util/monkey_patches_spec.rb

@@ -292,3 +292,9 @@ describe OpenSSL::SSL::SSLContext do
     ciphers.should be_empty
   end
 end
+
+describe SecureRandom do
+  it 'generates a properly formatted uuid' do
+    SecureRandom.uuid.should =~ /[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}/i
+  end
+end

data/spec/unit/util/network_device/config_spec.rb

@@ -7,117 +7,79 @@ describe Puppet::Util::NetworkDevice::Config do
   include PuppetSpec::Files
 
   before(:each) do
-    Puppet[:deviceconfig] = make_absolute("/dummy")
-    FileTest.stubs(:exists?).with(make_absolute("/dummy")).returns(true)
-  end
-
-  describe "when initializing" do
-    before :each do
-      Puppet::Util::NetworkDevice::Config.any_instance.stubs(:read)
-    end
-
-    it "should use the deviceconfig setting as pathname" do
-      Puppet.expects(:[]).with(:deviceconfig).returns(make_absolute("/dummy"))
-
-      Puppet::Util::NetworkDevice::Config.new
-    end
-
-    it "should raise an error if no file is defined finally" do
-      Puppet.expects(:[]).with(:deviceconfig).returns(nil)
-
-      lambda { Puppet::Util::NetworkDevice::Config.new }.should raise_error(Puppet::DevError)
-    end
-
-    it "should read and parse the file" do
-      Puppet::Util::NetworkDevice::Config.any_instance.expects(:read)
-
-      Puppet::Util::NetworkDevice::Config.new
-    end
+    Puppet[:deviceconfig] = tmpfile('deviceconfig')
   end
 
   describe "when parsing device" do
-    before :each do
-      @config = Puppet::Util::NetworkDevice::Config.new
-      @config.stubs(:changed?).returns(true)
-      @fd = stub 'fd'
-      File.stubs(:open).yields(@fd)
+    let(:config) { Puppet::Util::NetworkDevice::Config.new }
+
+    def write_device_config(*lines)
+      File.open(Puppet[:deviceconfig], 'w') {|f| f.puts lines}
     end
 
     it "should skip comments" do
-      @fd.stubs(:each).yields('  # comment')
-
-      OpenStruct.expects(:new).never
+      write_device_config('  # comment')
 
-      @config.read
+      config.devices.should be_empty
     end
 
     it "should increment line number even on commented lines" do
-      @fd.stubs(:each).multiple_yields('  # comment','[router.puppetlabs.com]')
+      write_device_config('  # comment','[router.puppetlabs.com]')
 
-      @config.read
-      @config.devices.should be_include('router.puppetlabs.com')
+      config.devices.should be_include('router.puppetlabs.com')
     end
 
     it "should skip blank lines" do
-      @fd.stubs(:each).yields('  ')
+      write_device_config('  ')
 
-      @config.read
-      @config.devices.should be_empty
+      config.devices.should be_empty
     end
 
     it "should produce the correct line number" do
-      @fd.stubs(:each).multiple_yields('  ', '[router.puppetlabs.com]')
+      write_device_config('  ', '[router.puppetlabs.com]')
 
-      @config.read
-      @config.devices['router.puppetlabs.com'].line.should == 2
+      config.devices['router.puppetlabs.com'].line.should == 2
     end
 
     it "should throw an error if the current device already exists" do
-      @fd.stubs(:each).multiple_yields('[router.puppetlabs.com]', '[router.puppetlabs.com]')
+      write_device_config('[router.puppetlabs.com]', '[router.puppetlabs.com]')
 
-      lambda { @config.read }.should raise_error
     end
 
     it "should accept device certname containing dashes" do
-      @fd.stubs(:each).yields('[router-1.puppetlabs.com]')
+      write_device_config('[router-1.puppetlabs.com]')
 
-      @config.read
-      @config.devices.should include('router-1.puppetlabs.com')
+      config.devices.should include('router-1.puppetlabs.com')
     end
 
     it "should create a new device for each found device line" do
-      @fd.stubs(:each).multiple_yields('[router.puppetlabs.com]', '[swith.puppetlabs.com]')
+      write_device_config('[router.puppetlabs.com]', '[swith.puppetlabs.com]')
 
-      @config.read
-      @config.devices.size.should == 2
+      config.devices.size.should == 2
     end
 
     it "should parse the device type" do
-      @fd.stubs(:each).multiple_yields('[router.puppetlabs.com]', 'type cisco')
+      write_device_config('[router.puppetlabs.com]', 'type cisco')
 
-      @config.read
-      @config.devices['router.puppetlabs.com'].provider.should == 'cisco'
+      config.devices['router.puppetlabs.com'].provider.should == 'cisco'
     end
 
     it "should parse the device url" do
-      @fd.stubs(:each).multiple_yields('[router.puppetlabs.com]', 'type cisco', 'url ssh://test/')
+      write_device_config('[router.puppetlabs.com]', 'type cisco', 'url ssh://test/')
 
-      @config.read
-      @config.devices['router.puppetlabs.com'].url.should == 'ssh://test/'
+      config.devices['router.puppetlabs.com'].url.should == 'ssh://test/'
     end
 
     it "should parse the debug mode" do
-      @fd.stubs(:each).multiple_yields('[router.puppetlabs.com]', 'type cisco', 'url ssh://test/', 'debug')
+      write_device_config('[router.puppetlabs.com]', 'type cisco', 'url ssh://test/', 'debug')
 
-      @config.read
-      @config.devices['router.puppetlabs.com'].options.should == { :debug => true }
+      config.devices['router.puppetlabs.com'].options.should == { :debug => true }
     end
 
     it "should set the debug mode to false by default" do
-      @fd.stubs(:each).multiple_yields('[router.puppetlabs.com]', 'type cisco', 'url ssh://test/')
+      write_device_config('[router.puppetlabs.com]', 'type cisco', 'url ssh://test/')
 
-      @config.read
-      @config.devices['router.puppetlabs.com'].options.should == { :debug => false }
+      config.devices['router.puppetlabs.com'].options.should == { :debug => false }
     end
   end
 

data/spec/unit/util/pidlock_spec.rb

@@ -45,11 +45,14 @@ describe Puppet::Util::Pidlock do
       @lock.lock.should be_true
     end
 
-
     it "should create a lock file" do
       @lock.lock
       File.should be_exists(@lockfile)
     end
+
+    it "should expose the lock file_path" do
+      @lock.file_path.should == @lockfile
+    end
   end
 
   describe "#unlock" do

data/spec/unit/util/tagging_spec.rb

@@ -42,27 +42,23 @@ describe Puppet::Util::Tagging, "when adding tags" do
   end
 
   it "should fail on tags containing '*' characters" do
-    lambda { @tagger.tag("bad*tag") }.should raise_error(Puppet::ParseError)
+    expect { @tagger.tag("bad*tag") }.to raise_error(Puppet::ParseError)
   end
 
   it "should fail on tags starting with '-' characters" do
-    lambda { @tagger.tag("-badtag") }.should raise_error(Puppet::ParseError)
+    expect { @tagger.tag("-badtag") }.to raise_error(Puppet::ParseError)
   end
 
   it "should fail on tags containing ' ' characters" do
-    lambda { @tagger.tag("bad tag") }.should raise_error(Puppet::ParseError)
+    expect { @tagger.tag("bad tag") }.to raise_error(Puppet::ParseError)
   end
 
   it "should allow alpha tags" do
-    lambda { @tagger.tag("good_tag") }.should_not raise_error(Puppet::ParseError)
+    expect { @tagger.tag("good_tag") }.to_not raise_error
   end
 
   it "should allow tags containing '.' characters" do
-    lambda { @tagger.tag("good.tag") }.should_not raise_error(Puppet::ParseError)
-  end
-
-  it "should provide a method for testing tag validity" do
-    @tagger.singleton_class.publicize_methods(:valid_tag?)  { @tagger.should be_respond_to(:valid_tag?) }
+    expect { @tagger.tag("good.tag") }.to_not raise_error
   end
 
   it "should add qualified classes as tags" do