puppet 2.6.4 → 2.6.5

data/spec/unit/application/kick_spec.rb

@@ -4,9 +4,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/kick'
 
-describe Puppet::Application::Kick do
-
-  confine "Kick's eventloops can only start on POSIX" => Puppet.features.posix?
+describe Puppet::Application::Kick, :if => Puppet.features.posix? do
 
   before :each do
     require 'puppet/util/ldap/connection'

data/spec/unit/application/master_spec.rb

@@ -412,9 +412,7 @@ describe Puppet::Application::Master do
         @master.main
       end
 
-      describe "with --rack" do
-        confine "Rack is not available" => Puppet.features.rack?
-
+      describe "with --rack", :if => Puppet.features.rack? do
         before do
           require 'puppet/network/http/rack'
           Puppet::Network::HTTP::Rack.stubs(:new).returns(@app)

data/spec/unit/application/queue_spec.rb

@@ -3,6 +3,7 @@
 require File.dirname(__FILE__) + '/../../spec_helper'
 
 require 'puppet/application/queue'
+require 'puppet/indirector/catalog/queue'
 
 describe Puppet::Application::Queue do
   before :each do

data/spec/unit/application_spec.rb

@@ -16,6 +16,25 @@ describe Puppet::Application do
     Puppet.settings.stubs(:parse)
   end
 
+  describe "finding" do
+    before do
+      @klass = Puppet::Application
+      @klass.stubs(:puts)
+    end
+
+    it "should find classes in the namespace" do
+      @klass.find("Agent").should == @klass::Agent
+    end
+
+    it "should not find classes outside the namespace" do
+      lambda { @klass.find("String") }.should raise_error(SystemExit)
+    end
+
+    it "should exit if it can't find a class" do
+      lambda { @klass.find("ThisShallNeverEverEverExistAsdf") }.should raise_error(SystemExit)
+    end
+  end
+
   describe ".run_mode" do
     it "should default to user" do
       @appclass.run_mode.name.should == :user
@@ -27,6 +46,48 @@ describe Puppet::Application do
     end
   end
 
+  it "should sadly and frighteningly allow run_mode to change at runtime" do
+    class TestApp < Puppet::Application
+      run_mode :master
+      def run_command
+        # This is equivalent to calling these methods externally to the
+        # instance, but since this is what "real world" code is likely to do
+        # (and we need the class anyway) we may as well test that. --daniel 2011-02-03
+        set_run_mode self.class.run_mode "agent"
+      end
+    end
+
+    Puppet[:run_mode].should == "user"
+
+    expect {
+      app = TestApp.new
+
+      Puppet[:run_mode].should == "master"
+
+      app.run
+
+      app.class.run_mode.name.should == :agent
+      $puppet_application_mode.name.should == :agent
+    }.should_not raise_error
+
+    Puppet[:run_mode].should == "agent"
+  end
+
+  it "it should not allow run mode to be set multiple times" do
+    pending "great floods of tears, you can do this right now" # --daniel 2011-02-03
+    app = Puppet::Application.new
+    expect {
+      app.set_run_mode app.class.run_mode "master"
+      $puppet_application_mode.name.should == :master
+      app.set_run_mode app.class.run_mode "agent"
+      $puppet_application_mode.name.should == :agent
+    }.should raise_error
+  end
+
+  it "should explode when an invalid run mode is set at runtime, for great victory"
+  # ...but you can, and while it will explode, that only happens too late for
+  # us to easily test. --daniel 2011-02-03
+
   it "should have a run entry-point" do
     @app.should respond_to(:run)
   end
@@ -160,9 +221,7 @@ describe Puppet::Application do
       end
     end
 
-    describe 'on POSIX systems' do
-      confine "HUP works only on POSIX systems" => Puppet.features.posix?
-
+    describe 'on POSIX systems', :if => Puppet.features.posix? do
       it 'should signal process with HUP after block if restart requested during block execution' do
         Puppet::Application.run_status = nil
         target = mock 'target'
@@ -224,8 +283,7 @@ describe Puppet::Application do
       @app.parse_options
     end
 
-    describe "when using --help" do
-      confine "rdoc" => Puppet.features.usage?
+    describe "when using --help", :if => Puppet.features.usage? do
 
       it "should call RDoc::usage and exit" do
         @app.expects(:exit)

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -11,6 +11,10 @@ end
 describe Puppet::Configurer::PluginHandler do
   before do
     @pluginhandler = PluginHandlerTester.new
+
+    # PluginHandler#load_plugin has an extra-strong rescue clause
+    # this mock is to make sure that we don't silently ignore errors
+    Puppet.expects(:err).never
   end
 
   it "should have a method for downloading plugins" do
@@ -80,7 +84,7 @@ describe Puppet::Configurer::PluginHandler do
   end
 
   it "should not try to load files that don't exist" do
-    FileTest.expects(:exist?).with("foo").returns true
+    FileTest.expects(:exist?).with("foo").returns false
     @pluginhandler.expects(:load).never
 
     @pluginhandler.load_plugin("foo")

data/spec/unit/configurer_spec.rb

@@ -72,14 +72,6 @@ describe Puppet::Configurer do
   end
 end
 
-describe Puppet::Configurer, "when initializing a report" do
-  it "should return an instance of a transaction report" do
-    Puppet.settings.stubs(:use).returns(true)
-    @agent = Puppet::Configurer.new
-    @agent.initialize_report.should be_instance_of(Puppet::Transaction::Report)
-  end
-end
-
 describe Puppet::Configurer, "when executing a catalog run" do
   before do
     Puppet.settings.stubs(:use).returns(true)
@@ -101,31 +93,31 @@ describe Puppet::Configurer, "when executing a catalog run" do
   end
 
   it "should initialize a transaction report if one is not provided" do
-    report = stub 'report'
-    @agent.expects(:initialize_report).returns report
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns report
 
     @agent.run
   end
 
   it "should pass the new report to the catalog" do
-    report = stub 'report'
-    @agent.stubs(:initialize_report).returns report
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.stubs(:new).returns report
     @catalog.expects(:apply).with{|options| options[:report] == report}
 
     @agent.run
   end
 
   it "should use the provided report if it was passed one" do
-    report = stub 'report'
-    @agent.expects(:initialize_report).never
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).never
     @catalog.expects(:apply).with{|options| options[:report] == report}
 
     @agent.run(:report => report)
   end
 
   it "should set the report as a log destination" do
-    report = stub 'report'
-    @agent.expects(:initialize_report).returns report
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns report
 
     Puppet::Util::Log.expects(:newdestination).with(report)
 
@@ -176,16 +168,16 @@ describe Puppet::Configurer, "when executing a catalog run" do
   end
 
   it "should send the report" do
-    report = stub 'report'
-    @agent.expects(:initialize_report).returns report
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
     @agent.expects(:send_report).with { |r, trans| r == report }
 
     @agent.run
   end
 
   it "should send the transaction report with a reference to the transaction if a run was actually made" do
-    report = stub 'report'
-    @agent.expects(:initialize_report).returns report
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
 
     trans = stub 'transaction'
     @catalog.expects(:apply).returns trans
@@ -198,8 +190,8 @@ describe Puppet::Configurer, "when executing a catalog run" do
   it "should send the transaction report even if the catalog could not be retrieved" do
     @agent.expects(:retrieve_catalog).returns nil
 
-    report = stub 'report'
-    @agent.expects(:initialize_report).returns report
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
     @agent.expects(:send_report)
 
     @agent.run
@@ -208,16 +200,16 @@ describe Puppet::Configurer, "when executing a catalog run" do
   it "should send the transaction report even if there is a failure" do
     @agent.expects(:retrieve_catalog).raises "whatever"
 
-    report = stub 'report'
-    @agent.expects(:initialize_report).returns report
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
     @agent.expects(:send_report)
 
     lambda { @agent.run }.should raise_error
   end
 
   it "should remove the report as a log destination when the run is finished" do
-    report = stub 'report'
-    @agent.expects(:initialize_report).returns report
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
 
     Puppet::Util::Log.expects(:close).with(report)
 
@@ -225,8 +217,8 @@ describe Puppet::Configurer, "when executing a catalog run" do
   end
 
   it "should return the report as the result of the run" do
-    report = stub 'report'
-    @agent.expects(:initialize_report).returns report
+    report = Puppet::Transaction::Report.new("apply")
+    Puppet::Transaction::Report.expects(:new).returns(report)
 
     @agent.run.should equal(report)
   end
@@ -237,20 +229,12 @@ describe Puppet::Configurer, "when sending a report" do
     Puppet.settings.stubs(:use).returns(true)
     @configurer = Puppet::Configurer.new
 
-    @report = stub 'report'
+    @report = Puppet::Transaction::Report.new("apply")
     @trans = stub 'transaction'
   end
 
-  it "should require a report" do
-    lambda { @configurer.send_report }.should raise_error(ArgumentError)
-  end
-
-  it "should allow specification of a transaction" do
-    lambda { @configurer.send_report(@report, @trans)  }.should_not raise_error(ArgumentError)
-  end
-
-  it "should use any provided transaction to add metrics to the report" do
-    @trans.expects(:generate_report)
+  it "should finalize the report" do
+    @report.expects(:finalize_report)
     @configurer.send_report(@report, @trans)
   end
 
@@ -260,28 +244,28 @@ describe Puppet::Configurer, "when sending a report" do
     @report.expects(:summary).returns "stuff"
 
     @configurer.expects(:puts).with("stuff")
-    @configurer.send_report(@report)
+    @configurer.send_report(@report, nil)
   end
 
   it "should not print a report summary if not configured to do so" do
     Puppet.settings[:summarize] = false
 
     @configurer.expects(:puts).never
-    @configurer.send_report(@report)
+    @configurer.send_report(@report, nil)
   end
 
   it "should save the report if reporting is enabled" do
     Puppet.settings[:report] = true
 
     @report.expects(:save)
-    @configurer.send_report(@report)
+    @configurer.send_report(@report, nil)
   end
 
   it "should not save the report if reporting is disabled" do
     Puppet.settings[:report] = false
 
     @report.expects(:save).never
-    @configurer.send_report(@report)
+    @configurer.send_report(@report, nil)
   end
 
   it "should log but not fail if saving the report fails" do
@@ -290,7 +274,7 @@ describe Puppet::Configurer, "when sending a report" do
     @report.expects(:save).raises "whatever"
 
     Puppet.expects(:err)
-    lambda { @configurer.send_report(@report) }.should_not raise_error
+    lambda { @configurer.send_report(@report, nil) }.should_not raise_error
   end
 end
 
@@ -418,7 +402,7 @@ describe Puppet::Configurer, "when retrieving a catalog" do
   end
 
   it "should return nil if there is an error while retrieving the catalog" do
-    Puppet::Resource::Catalog.expects(:find).raises "eh"
+    Puppet::Resource::Catalog.expects(:find).at_least_once.raises "eh"
 
     @agent.retrieve_catalog.should be_nil
   end
@@ -472,23 +456,23 @@ describe Puppet::Configurer, "when preparing for a run" do
   it "should initialize the metadata store" do
     @agent.class.stubs(:facts).returns(@facts)
     @agent.expects(:dostorage)
-    @agent.prepare
+    @agent.prepare({})
   end
 
   it "should download fact plugins" do
     @agent.expects(:download_fact_plugins)
 
-    @agent.prepare
+    @agent.prepare({})
   end
 
   it "should download plugins" do
     @agent.expects(:download_plugins)
 
-    @agent.prepare
+    @agent.prepare({})
   end
 
   it "should perform the pre-run commands" do
     @agent.expects(:execute_prerun_command)
-    @agent.prepare
+    @agent.prepare({})
   end
 end

data/spec/unit/file_bucket/dipper_spec.rb

@@ -2,121 +2,113 @@
 
 require File.dirname(__FILE__) + '/../../spec_helper'
 
+require 'pathname'
+
 require 'puppet/file_bucket/dipper'
+require 'puppet/indirector/file_bucket_file/rest'
+
 describe Puppet::FileBucket::Dipper do
-  before do
-    ['/my/file'].each do |x|
-      Puppet::FileBucket::Dipper.any_instance.stubs(:absolutize_path).with(x).returns(x)
-    end
+  include PuppetSpec::Files
+
+  def make_tmp_file(contents)
+    file = tmpfile("file_bucket_file")
+    File.open(file, 'w') { |f| f.write(contents) }
+    file
   end
 
-  it "should fail in an informative way when there are failures backing up to the server" do
-    File.stubs(:exist?).returns true
-    File.stubs(:read).returns "content"
+  it "should fail in an informative way when there are failures checking for the file on the server" do
+    @dipper = Puppet::FileBucket::Dipper.new(:Path => "/my/bucket")
+
+    file = make_tmp_file('contents')
+    Puppet::FileBucket::File.expects(:head).raises ArgumentError
 
+    lambda { @dipper.backup(file) }.should raise_error(Puppet::Error)
+  end
+
+  it "should fail in an informative way when there are failures backing up to the server" do
     @dipper = Puppet::FileBucket::Dipper.new(:Path => "/my/bucket")
 
-    filemock = stub "bucketfile"
-    Puppet::FileBucket::File.stubs(:new).returns(filemock)
-    filemock.expects(:name).returns "name"
-    filemock.expects(:save).raises ArgumentError
+    file = make_tmp_file('contents')
+    Puppet::FileBucket::File.expects(:head).returns false
+    Puppet::FileBucket::File.any_instance.expects(:save).raises ArgumentError
 
-    lambda { @dipper.backup("/my/file") }.should raise_error(Puppet::Error)
+    lambda { @dipper.backup(file) }.should raise_error(Puppet::Error)
   end
 
   it "should backup files to a local bucket" do
-    @dipper = Puppet::FileBucket::Dipper.new(
-      :Path => "/my/bucket"
-    )
+    Puppet[:bucketdir] = "/non/existent/directory"
+    file_bucket = tmpdir("bucket")
 
-    File.stubs(:exist?).returns true
-    File.stubs(:read).with("/my/file").returns "my contents"
+    @dipper = Puppet::FileBucket::Dipper.new(:Path => file_bucket)
 
-    bucketfile = stub "bucketfile"
-    bucketfile.stubs(:name).returns('md5/DIGEST123')
-    bucketfile.stubs(:checksum_data).returns("DIGEST123")
-    bucketfile.expects(:save).with('md5/DIGEST123')
+    file = make_tmp_file('my contents')
+    checksum = "2975f560750e71c478b8e3b39a956adb"
+    Digest::MD5.hexdigest('my contents').should == checksum
 
+    @dipper.backup(file).should == checksum
+    File.exists?("#{file_bucket}/2/9/7/5/f/5/6/0/2975f560750e71c478b8e3b39a956adb/contents").should == true
+  end
+
+  it "should not backup a file that is already in the bucket" do
+    @dipper = Puppet::FileBucket::Dipper.new(:Path => "/my/bucket")
 
-          Puppet::FileBucket::File.stubs(:new).with(
-                
-      "my contents",
-      :bucket_path => '/my/bucket',
-        
-      :path => '/my/file'
-    ).returns(bucketfile)
+    file = make_tmp_file('my contents')
+    checksum = Digest::MD5.hexdigest('my contents')
 
-    @dipper.backup("/my/file").should == "DIGEST123"
+    Puppet::FileBucket::File.expects(:head).returns true
+    Puppet::FileBucket::File.any_instance.expects(:save).never
+    @dipper.backup(file).should == checksum
   end
 
   it "should retrieve files from a local bucket" do
-    @dipper = Puppet::FileBucket::Dipper.new(
-      :Path => "/my/bucket"
-    )
+    @dipper = Puppet::FileBucket::Dipper.new(:Path => "/my/bucket")
+
+    checksum = Digest::MD5.hexdigest('my contents')
 
-    File.stubs(:exist?).returns true
-    File.stubs(:read).with("/my/file").returns "my contents"
+    request = nil
 
-    bucketfile = stub "bucketfile"
-    bucketfile.stubs(:to_s).returns "Content"
+    Puppet::FileBucketFile::File.any_instance.expects(:find).with{ |r| request = r }.once.returns(Puppet::FileBucket::File.new('my contents'))
 
-    Puppet::FileBucket::File.expects(:find).with{|x,opts|
-      x == 'md5/DIGEST123'
-    }.returns(bucketfile)
+    @dipper.getfile(checksum).should == 'my contents'
 
-    @dipper.getfile("DIGEST123").should == "Content"
+    request.key.should == "md5/#{checksum}"
   end
 
   it "should backup files to a remote server" do
+    @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
 
-          @dipper = Puppet::FileBucket::Dipper.new(
-                
-      :Server => "puppetmaster",
-        
-      :Port   => "31337"
-    )
+    file = make_tmp_file('my contents')
+    checksum = Digest::MD5.hexdigest('my contents')
 
-    File.stubs(:exist?).returns true
-    File.stubs(:read).with("/my/file").returns "my contents"
+    real_path = Pathname.new(file).realpath
 
-    bucketfile = stub "bucketfile"
-    bucketfile.stubs(:name).returns('md5/DIGEST123')
-    bucketfile.stubs(:checksum_data).returns("DIGEST123")
-    bucketfile.expects(:save).with('https://puppetmaster:31337/production/file_bucket_file/md5/DIGEST123')
+    request1 = nil
+    request2 = nil
 
+    Puppet::FileBucketFile::Rest.any_instance.expects(:head).with { |r| request1 = r }.once.returns(nil)
+    Puppet::FileBucketFile::Rest.any_instance.expects(:save).with { |r| request2 = r }.once
 
-          Puppet::FileBucket::File.stubs(:new).with(
-                
-      "my contents",
-      :bucket_path => nil,
-        
-      :path => '/my/file'
-    ).returns(bucketfile)
-
-    @dipper.backup("/my/file").should == "DIGEST123"
+    @dipper.backup(file).should == checksum
+    [request1, request2].each do |r|
+      r.server.should == 'puppetmaster'
+      r.port.should == 31337
+      r.key.should == "md5/#{checksum}#{real_path}"
+    end
   end
 
   it "should retrieve files from a remote server" do
+    @dipper = Puppet::FileBucket::Dipper.new(:Server => "puppetmaster", :Port => "31337")
 
-          @dipper = Puppet::FileBucket::Dipper.new(
-                
-      :Server => "puppetmaster",
-        
-      :Port   => "31337"
-    )
+    checksum = Digest::MD5.hexdigest('my contents')
 
-    File.stubs(:exist?).returns true
-    File.stubs(:read).with("/my/file").returns "my contents"
+    request = nil
 
-    bucketfile = stub "bucketfile"
-    bucketfile.stubs(:to_s).returns "Content"
+    Puppet::FileBucketFile::Rest.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new('my contents'))
 
-    Puppet::FileBucket::File.expects(:find).with{|x,opts|
-      x == 'https://puppetmaster:31337/production/file_bucket_file/md5/DIGEST123'
-    }.returns(bucketfile)
+    @dipper.getfile(checksum).should == "my contents"
 
-    @dipper.getfile("DIGEST123").should == "Content"
+    request.server.should == 'puppetmaster'
+    request.port.should == 31337
+    request.key.should == "md5/#{checksum}"
   end
-
-
 end