puppet 2.6.2 → 2.6.3

data/spec/unit/resource/type_spec.rb

@@ -580,29 +580,29 @@ describe Puppet::Resource::Type do
     end
 
     it "should create a resource instance" do
-      @top.mk_plain_resource(@scope).should be_instance_of(Puppet::Parser::Resource)
+      @top.ensure_in_catalog(@scope).should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should set its resource type to 'class' when it is a hostclass" do
-      Puppet::Resource::Type.new(:hostclass, "top").mk_plain_resource(@scope).type.should == "Class"
+      Puppet::Resource::Type.new(:hostclass, "top").ensure_in_catalog(@scope).type.should == "Class"
     end
 
     it "should set its resource type to 'node' when it is a node" do
-      Puppet::Resource::Type.new(:node, "top").mk_plain_resource(@scope).type.should == "Node"
+      Puppet::Resource::Type.new(:node, "top").ensure_in_catalog(@scope).type.should == "Node"
     end
 
     it "should fail when it is a definition" do
-      lambda { Puppet::Resource::Type.new(:definition, "top").mk_plain_resource(@scope) }.should raise_error(ArgumentError)
+      lambda { Puppet::Resource::Type.new(:definition, "top").ensure_in_catalog(@scope) }.should raise_error(ArgumentError)
     end
 
     it "should add the created resource to the scope's catalog" do
-      @top.mk_plain_resource(@scope)
+      @top.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
 
     it "should evaluate the parent class if one exists" do
-      @middle.mk_plain_resource(@scope)
+      @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should be_instance_of(Puppet::Parser::Resource)
     end
@@ -610,40 +610,40 @@ describe Puppet::Resource::Type do
     it "should fail to evaluate if a parent class is defined but cannot be found" do
       othertop = Puppet::Resource::Type.new :hostclass, "something", :parent => "yay"
       @code.add othertop
-      lambda { othertop.mk_plain_resource(@scope) }.should raise_error(Puppet::ParseError)
+      lambda { othertop.ensure_in_catalog(@scope) }.should raise_error(Puppet::ParseError)
     end
 
     it "should not create a new resource if one already exists" do
       @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
       @compiler.catalog.expects(:add_resource).never
-      @top.mk_plain_resource(@scope)
+      @top.ensure_in_catalog(@scope)
     end
 
     it "should return the existing resource when not creating a new one" do
       @compiler.catalog.expects(:resource).with(:class, "top").returns("something")
       @compiler.catalog.expects(:add_resource).never
-      @top.mk_plain_resource(@scope).should == "something"
+      @top.ensure_in_catalog(@scope).should == "something"
     end
 
     it "should not create a new parent resource if one already exists and it has a parent class" do
-      @top.mk_plain_resource(@scope)
+      @top.ensure_in_catalog(@scope)
 
       top_resource = @compiler.catalog.resource(:class, "top")
 
-      @middle.mk_plain_resource(@scope)
+      @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.resource(:class, "top").should equal(top_resource)
     end
 
     # #795 - tag before evaluation.
     it "should tag the catalog with the resource tags when it is evaluated" do
-      @middle.mk_plain_resource(@scope)
+      @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.should be_tagged("middle")
     end
 
     it "should tag the catalog with the parent class tags when it is evaluated" do
-      @middle.mk_plain_resource(@scope)
+      @middle.ensure_in_catalog(@scope)
 
       @compiler.catalog.should be_tagged("top")
     end

data/spec/unit/type/schedule_spec.rb

@@ -13,14 +13,6 @@ module ScheduleTesting
     Time.at(diff)
   end
 
-  def month(method, count)
-    diff(:hour, 3600 * 24 * 30, method, count)
-  end
-
-  def week(method, count)
-    diff(:hour, 3600 * 24 * 7, method, count)
-  end
-
   def day(method, count)
     diff(:hour, 3600 * 24, method, count)
   end
@@ -33,10 +25,6 @@ module ScheduleTesting
     diff(:min, 60, method, count)
   end
 
-  def sec(method, count)
-    diff(:sec, 1, method, count)
-  end
-
 end
 
 describe Puppet::Type.type(:schedule) do
@@ -194,26 +182,18 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match if the times are one minute apart and the current minute is 0" do
-      current = Time.now
+      current = Time.utc(2008, 1, 1, 0, 0, 0)
+      previous = Time.utc(2007, 12, 31, 23, 59, 0)
 
-      # Subtract an hour, reset the minute to zero, then add 59 minutes, so we're the previous hour plus 59 minutes.
-      previous = (current - 3600 - (current.min * 60) + (59 * 60))
-
-      # Now set the "current" time to the zero minute of the current hour.
-      now = (current - (current.min * 60))
-      Time.stubs(:now).returns(now)
+      Time.stubs(:now).returns(current)
       @schedule.match?(previous).should be_true
     end
 
-    it "should not match if the times are 58 minutes apart and the current minute is 59" do
-      current = Time.now
+    it "should not match if the times are 59 minutes apart and the current minute is 59" do
+      current = Time.utc(2009, 2, 1, 12, 59, 0)
+      previous = Time.utc(2009, 2, 1, 12, 0, 0)
 
-      # reset the minute to zero
-      previous = current - (current.min * 60)
-
-      # Now set the "current" time to the 59th minute of the current hour.
-      now = (current - (current.min * 60) + (59 * 60))
-      Time.stubs(:now).returns(now)
+      Time.stubs(:now).returns(current)
       @schedule.match?(previous).should be_false
     end
   end
@@ -227,10 +207,7 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match if the times are one minute apart and the current minute and hour are 0" do
-      zero = Time.now
-
-      # Reset the current time to X:00:00
-      current = zero - (zero.hour * 3600) - (zero.min * 60) - zero.sec
+      current = Time.utc(2010, "nov", 7, 0, 0, 0)
 
       # Now set the previous time to one minute before that
       previous = current - 60
@@ -240,10 +217,9 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should not match if the times are 23 hours and 58 minutes apart and the current hour is 23 and the current minute is 59" do
-      zero = Time.now
 
       # Reset the previous time to 00:00:00
-      previous = zero - (zero.hour * 3600) - (zero.min * 60) - zero.sec
+      previous = Time.utc(2010, "nov", 7, 0, 0, 0)
 
       # Set the current time to 23:59
       now = previous + (23 * 3600) + (59 * 60)
@@ -262,19 +238,17 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match if the previous time is prior to the most recent Sunday" do
-      now = Time.now
-
-      # Subtract the number days we've progressed into the week, plus one because we're zero-indexed.
-      previous = now - (3600 * 24 * (now.wday + 1))
+      now = Time.utc(2010, "nov", 11, 0, 0, 0) # Thursday
+      Time.stubs(:now).returns(now)
+      previous = Time.utc(2010, "nov", 6, 23, 59, 59) # Sat
 
       @schedule.match?(previous).should be_true
     end
 
     it "should not match if the previous time is after the most recent Saturday" do
-      now = Time.now
-
-      # Subtract the number days we've progressed into the week
-      previous = now - (3600 * 24 * now.wday)
+      now = Time.utc(2010, "nov", 11, 0, 0, 0) # Thursday
+      Time.stubs(:now).returns(now)
+      previous = Time.utc(2010, "nov", 7, 0, 0, 0) # Sunday
 
       @schedule.match?(previous).should be_false
     end
@@ -289,19 +263,17 @@ describe Puppet::Type.type(:schedule) do
     end
 
     it "should match when the previous time is prior to the first day of this month" do
-      now = Time.now
-
-      # Subtract the number days we've progressed into the month
-      previous = now - (3600 * 24 * now.day)
+      now = Time.utc(2010, "nov", 8, 00, 59, 59)
+      Time.stubs(:now).returns(now)
+      previous = Time.utc(2010, "oct", 31, 23, 59, 59)
 
       @schedule.match?(previous).should be_true
     end
 
     it "should not match when the previous time is after the last day of last month" do
-      now = Time.now
-
-      # Subtract the number days we've progressed into the month, minus one
-      previous = now - (3600 * 24 * (now.day - 1))
+      now = Time.utc(2010, "nov", 8, 00, 59, 59)
+      Time.stubs(:now).returns(now)
+      previous = Time.utc(2010, "nov", 1, 0, 0, 0)
 
       @schedule.match?(previous).should be_false
     end

data/spec/unit/util/command_line_spec.rb

@@ -86,7 +86,7 @@ describe Puppet::Util::CommandLine do
   describe "when the subcommand is not implemented" 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(:binary).with('puppet-whatever').returns('/dev/null/puppet-whatever')
+      Puppet::Util.expects(:which).with('puppet-whatever').returns('/dev/null/puppet-whatever')
       commandline.expects(:system).with('/dev/null/puppet-whatever', 'argument')
 
       commandline.execute
@@ -95,7 +95,7 @@ describe Puppet::Util::CommandLine do
     describe "and an external implementation cannot be found" do
       it "should abort and show the usage message" do
         commandline = Puppet::Util::CommandLine.new("puppet", ['whatever', 'argument'], @tty)
-        Puppet::Util.expects(:binary).with('puppet-whatever').returns(nil)
+        Puppet::Util.expects(:which).with('puppet-whatever').returns(nil)
         commandline.expects(:system).never
 
         commandline.expects(:usage_message).returns("the usage message")

data/spec/unit/util/file_locking_spec.rb

@@ -32,17 +32,12 @@ describe Puppet::Util::FileLocking do
     end
 
     it "should use a global shared mutex" do
-      @sync = mock 'sync'
-      @sync.expects(:synchronize).with(Sync::SH).once
-      Puppet::Util.expects(:sync).with('/file').returns @sync
-
+      Puppet::Util.expects(:synchronize_on).with('/file',Sync::SH).once
       Puppet::Util::FileLocking.readlock '/file'
     end
 
     it "should use a shared lock on the file" do
-      @sync = mock 'sync'
-      @sync.stubs(:synchronize).yields
-      Puppet::Util.expects(:sync).with('/file').returns @sync
+      Puppet::Util.expects(:synchronize_on).with('/file',Sync::SH).yields
 
       fh = mock 'filehandle'
       File.expects(:open).with("/file").yields fh
@@ -59,9 +54,7 @@ describe Puppet::Util::FileLocking do
     end
 
     it "should create missing files" do
-      @sync = mock 'sync'
-      @sync.stubs(:synchronize).yields
-      Puppet::Util.expects(:sync).with('/file').returns @sync
+      Puppet::Util.expects(:synchronize_on).with('/file',Sync::SH).yields
 
       File.expects(:exists?).with('/file').returns false
       File.expects(:open).with('/file').once
@@ -72,9 +65,7 @@ describe Puppet::Util::FileLocking do
 
   describe "when acquiring a write lock" do
     before do
-      @sync = mock 'sync'
-      Puppet::Util.stubs(:sync).returns @sync
-      @sync.stubs(:synchronize).yields
+      Puppet::Util.stubs(:synchronize_on).yields
       File.stubs(:file?).with('/file').returns true
       File.stubs(:exists?).with('/file').returns true
     end
@@ -88,29 +79,26 @@ describe Puppet::Util::FileLocking do
     end
 
     it "should use a global exclusive mutex" do
-      sync = mock 'sync'
-      sync.expects(:synchronize).with(Sync::EX)
-      Puppet::Util.expects(:sync).with("/file").returns sync
-
+      Puppet::Util.expects(:synchronize_on).with("/file",Sync::EX)
       Puppet::Util::FileLocking.writelock '/file'
     end
 
     it "should use any specified mode when opening the file" do
-      File.expects(:open).with("/file", "w", :mymode)
+      File.expects(:open).with("/file", File::Constants::CREAT | File::Constants::WRONLY , :mymode)
 
       Puppet::Util::FileLocking.writelock('/file', :mymode)
     end
 
     it "should use the mode of the existing file if no mode is specified" do
       File.expects(:stat).with("/file").returns(mock("stat", :mode => 0755))
-      File.expects(:open).with("/file", "w", 0755)
+      File.expects(:open).with("/file", File::Constants::CREAT | File::Constants::WRONLY, 0755)
 
       Puppet::Util::FileLocking.writelock('/file')
     end
 
     it "should use 0600 as the mode if no mode is specified and the file does not exist" do
       File.expects(:stat).raises(Errno::ENOENT)
-      File.expects(:open).with("/file", "w", 0600)
+      File.expects(:open).with("/file", File::Constants::CREAT | File::Constants::WRONLY, 0600)
 
       Puppet::Util::FileLocking.writelock('/file')
     end
@@ -130,6 +118,8 @@ describe Puppet::Util::FileLocking do
       lfh = mock 'locked_filehandle'
       fh.expects(:lock_exclusive).yields(lfh)
 
+      lfh.stubs(:seek)
+      lfh.stubs(:truncate)
       lfh.expects(:print).with "foo"
 
       Puppet::Util::FileLocking.writelock('/file') do |f|
@@ -137,18 +127,32 @@ describe Puppet::Util::FileLocking do
       end
     end
 
+    it "should truncate the file under an exclusive lock" do
+      fh = mock 'fh'
+      File.expects(:open).yields fh
+
+      lfh = mock 'locked_filehandle'
+      fh.expects(:lock_exclusive).yields(lfh)
+
+      lfh.expects(:seek).with(0, IO::SEEK_SET)
+      lfh.expects(:truncate).with(0)
+      lfh.stubs(:print)
+
+      Puppet::Util::FileLocking.writelock('/file') do |f|
+        f.print "foo"
+      end
+    end
+
     it "should only work on regular files" do
       File.expects(:file?).with('/file').returns false
       proc { Puppet::Util::FileLocking.writelock('/file') }.should raise_error(ArgumentError)
     end
 
     it "should create missing files" do
-      @sync = mock 'sync'
-      @sync.stubs(:synchronize).yields
-      Puppet::Util.expects(:sync).with('/file').returns @sync
+      Puppet::Util.expects(:synchronize_on).with('/file',Sync::EX).yields
 
       File.expects(:exists?).with('/file').returns false
-      File.expects(:open).with('/file', 'w', 0600).once
+      File.expects(:open).with('/file', File::Constants::CREAT | File::Constants::WRONLY, 0600).once
 
       Puppet::Util::FileLocking.writelock('/file')
     end

data/spec/unit/util/{json_spec.rb → pson_spec.rb}

@@ -18,4 +18,21 @@ describe Puppet::Util::Pson do
     pson.expects(:from_pson).with("mydata")
     pson.pson_create("type" => "foo", "data" => "mydata")
   end
+
+
+  { 
+    'foo' => '"foo"',
+    1 => '1',
+    "\x80" => "\"\x80\"",
+    [] => '[]'
+  }.each { |str,pson|
+    it "should be able to encode #{str.inspect}" do
+      str.to_pson.should == pson
+    end
+  }
+
+  it "should be able to handle arbitrary binary data" do
+    bin_string = (1..20000).collect { |i| ((17*i+13*i*i) % 255).chr }.join
+    PSON.parse(%Q{{ "type": "foo", "data": #{bin_string.to_pson} }})["data"].should == bin_string
+  end
 end

data/spec/unit/util/rdoc_spec.rb

@@ -43,12 +43,20 @@ describe Puppet::Util::RDoc do
       Puppet::Util::RDoc.rdoc("output", [], "utf-8")
     end
 
-    it "should tell RDoc to force updates of indices" do
+    it "should tell RDoc to force updates of indices when RDoc supports it" do
+      Options::OptionList.stubs(:options).returns([["--force-update", "-U", 0 ]])
       @rdoc.expects(:document).with { |args| args.include?("--force-update") }
 
       Puppet::Util::RDoc.rdoc("output", [])
     end
 
+    it "should not tell RDoc to force updates of indices when RDoc doesn't support it" do
+      Options::OptionList.stubs(:options).returns([])
+      @rdoc.expects(:document).never.with { |args| args.include?("--force-update") }
+
+      Puppet::Util::RDoc.rdoc("output", [])
+    end
+
     it "should tell RDoc to use the given outputdir" do
       @rdoc.expects(:document).with { |args| args.include?("--op") and args.include?("myoutputdir") }
 

data/spec/unit/util/storage_spec.rb

@@ -3,15 +3,14 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'yaml'
-require 'tempfile'
-
 require 'puppet/util/storage'
 
 describe Puppet::Util::Storage do
+  include PuppetSpec::Files
 
   before(:all) do
     @basepath = Puppet.features.posix? ? "/somepath" : "C:/somepath"
-    Puppet[:statedir] = Dir.tmpdir
+    Puppet[:statedir] = tmpdir("statedir")
   end
 
   after(:all) do

data/test/other/provider.rb

@@ -70,24 +70,13 @@ class TestImpl < Test::Unit::TestCase
       child = @type.provide("child", :parent => parent.name) {}
     }
 
-    assert_nothing_raised {
-      child.commands :which => "which"
-    }
-
-    assert(child.command(:which), "Did not find 'which' command")
-
-    assert(child.command(:which) =~ /^\//,
-        "Command did not become fully qualified")
-    assert(FileTest.exists?(child.command(:which)),
-                "Did not find actual 'which' binary")
-
     assert_raise(Puppet::DevError) do
       child.command(:nosuchcommand)
     end
 
     # Now create a parent command
     assert_nothing_raised {
-      parent.commands :sh => Puppet::Util.binary('sh')
+      parent.commands :sh => Puppet::Util.which('sh')
     }
 
     assert(parent.command(:sh), "Did not find 'sh' command")

data/test/other/report.rb

@@ -35,10 +35,7 @@ class TestReports < Test::Unit::TestCase
     config.retrieval_duration = 0.001
     trans = config.apply
 
-    report = Puppet::Transaction::Report.new
-    trans.add_metrics_to_report(report)
-
-    report
+    trans.generate_report
   end
 
   # Make sure we can use reports as log destinations.
@@ -95,7 +92,7 @@ class TestReports < Test::Unit::TestCase
     assert_equal(yaml, File.read(file), "File did not get written")
   end
 
-  if Puppet.features.rrd?
+  if Puppet.features.rrd? || Puppet.features.rrd_legacy?
   def test_rrdgraph_report
     Puppet.settings.use(:main, :metrics)
     report = mkreport