puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/application/apply_spec.rb

@@ -148,7 +148,7 @@ describe Puppet::Application::Apply do
 
         STDIN.stubs(:read)
 
-        @transaction = Puppet::Transaction.new(@catalog)
+        @transaction = stub('transaction')
         @catalog.stubs(:apply).returns(@transaction)
 
         Puppet::Util::Storage.stubs(:load)

data/spec/unit/application/doc_spec.rb

@@ -13,7 +13,7 @@ describe Puppet::Application::Doc do
     Puppet::Util::Log.stubs(:newdestination)
   end
 
-  it "should declare a other command" do
+  it "should declare an other command" do
     @doc.should respond_to(:other)
   end
 

data/spec/unit/application/face_base_spec.rb

@@ -33,7 +33,7 @@ describe Puppet::Application::FaceBase do
     end
 
     describe "with just an action" do
-      before :all do
+      before(:each) do
         # We have to stub Signal.trap to avoid a crazy mess where we take
         # over signal handling and make it impossible to cancel the test
         # suite run.
@@ -304,8 +304,8 @@ describe Puppet::Application::FaceBase do
       end
 
       [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
-        it "should render #{input.class} using JSON" do
-          app.render(input, {}).should == input.to_pson.chomp
+        it "should render Array as one item per line" do
+          app.render(input, {}).should == input.collect { |item| item.to_s + "\n" }.join('')
         end
       end
 

data/spec/unit/application/facts_spec.rb

@@ -16,6 +16,7 @@ describe Puppet::Application::Facts do
   end
 
   it "should return facts if a key is given to find" do
+    Puppet[:stringify_facts] = false
     Puppet::Node::Facts.indirection.reset_terminus_class
     Puppet::Node::Facts.indirection.expects(:find).returns(Puppet::Node::Facts.new('whatever', {}))
     subject.command_line.stubs(:args).returns %w{find whatever --render-as yaml}

data/spec/unit/application/master_spec.rb

@@ -47,21 +47,6 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
 
       @master.preinit
     end
-
-    it "should create a Puppet Daemon" do
-      Puppet::Daemon.expects(:new).returns(@daemon)
-
-      @master.preinit
-    end
-
-    it "should give ARGV to the Daemon" do
-      argv = stub 'argv'
-      ARGV.stubs(:dup).returns(argv)
-      @daemon.expects(:argv=).with(argv)
-
-      @master.preinit
-    end
-
   end
 
   [:debug,:verbose].each do |option|

data/spec/unit/application/queue_spec.rb

@@ -8,7 +8,6 @@ describe Puppet::Application::Queue, :unless => Puppet.features.microsoft_window
   before :each do
     @queue = Puppet::Application[:queue]
     @queue.stubs(:puts)
-    @daemon = stub_everything 'daemon'
     Puppet::Util::Log.stubs(:newdestination)
 
     Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
@@ -40,14 +39,6 @@ describe Puppet::Application::Queue, :unless => Puppet.features.microsoft_window
 
       @queue.options[:debug].should be_false
     end
-
-    it "should create a Daemon instance and copy ARGV to it" do
-      ARGV.expects(:dup).returns "eh"
-      daemon = mock("daemon")
-      daemon.expects(:argv=).with("eh")
-      Puppet::Daemon.expects(:new).returns daemon
-      @queue.preinit
-    end
   end
 
   describe "when handling options" do
@@ -65,10 +56,13 @@ describe Puppet::Application::Queue, :unless => Puppet.features.microsoft_window
   end
 
   describe "during setup" do
+    let(:daemon) { stub("Daemon", :daemonize => nil, :argv= => []) }
+
     before :each do
+      Puppet::Daemon.stubs(:new).returns(daemon)
+
       @queue.preinit
       @queue.options.stubs(:[])
-      @queue.daemon.stubs(:daemonize)
       Puppet.stubs(:info)
       Puppet.features.stubs(:stomp?).returns true
       Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
@@ -79,7 +73,7 @@ describe Puppet::Application::Queue, :unless => Puppet.features.microsoft_window
 
     it "should fail if the stomp feature is missing" do
       Puppet.features.expects(:stomp?).returns false
-      lambda { @queue.setup }.should raise_error(ArgumentError)
+      expect { @queue.setup }.to raise_error(ArgumentError)
     end
 
     it "should issue a warning that queue is deprecated" do
@@ -139,7 +133,7 @@ describe Puppet::Application::Queue, :unless => Puppet.features.microsoft_window
     it "should daemonize if needed" do
       Puppet[:daemonize] = true
 
-      @queue.daemon.expects(:daemonize)
+      daemon.expects(:daemonize)
 
       @queue.setup
     end

data/spec/unit/application/resource_spec.rb

@@ -36,7 +36,7 @@ describe Puppet::Application::Resource do
       @resource_app.host.should == :whatever
     end
 
-    it "should load an display all types with types option" do
+    it "should load a display all types with types option" do
       type1 = stub_everything 'type1', :name => :type1
       type2 = stub_everything 'type2', :name => :type2
       Puppet::Type.stubs(:loadall)

data/spec/unit/configurer/fact_handler_spec.rb

@@ -5,19 +5,19 @@ require 'puppet/configurer/fact_handler'
 
 class FactHandlerTester
   include Puppet::Configurer::FactHandler
+
+  def reload_facter
+    # don't want to do this in tests
+  end
 end
 
 describe Puppet::Configurer::FactHandler do
-  before do
+  before :each do
     @facthandler = FactHandlerTester.new
+    Puppet::Node::Facts.indirection.terminus_class = :memory
   end
 
   describe "when finding facts" do
-    before :each do
-      @facthandler.stubs(:reload_facter)
-      Puppet::Node::Facts.indirection.terminus_class = :memory
-    end
-
     it "should use the node name value to retrieve the facts" do
       foo_facts = Puppet::Node::Facts.new('foo')
       bar_facts = Puppet::Node::Facts.new('bar')
@@ -48,61 +48,30 @@ describe Puppet::Configurer::FactHandler do
     end
 
     it "should fail if finding facts fails" do
-      Puppet[:trace] = false
-      Puppet[:certname] = "myhost"
       Puppet::Node::Facts.indirection.expects(:find).raises RuntimeError
 
-      lambda { @facthandler.find_facts }.should raise_error(Puppet::Error)
+      expect { @facthandler.find_facts }.to raise_error(Puppet::Error, /Could not retrieve local facts/)
     end
-  end
 
-  it "should only load fact plugins once" do
-    Puppet::Node::Facts.indirection.expects(:find).once
-    @facthandler.find_facts
+    it "should only load fact plugins once" do
+      Puppet::Node::Facts.indirection.expects(:find).once
+      @facthandler.find_facts
+    end
   end
 
-  # I couldn't get marshal to work for this, only yaml, so we hard-code yaml.
   it "should serialize and CGI escape the fact values for uploading" do
-    facts = stub 'facts'
-    facts.expects(:support_format?).with(:b64_zlib_yaml).returns true
-    facts.expects(:render).returns "my text"
-    text = CGI.escape("my text")
+    facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
+    Puppet::Node::Facts.indirection.save(facts)
+    text = CGI.escape(@facthandler.find_facts.render(:pson))
 
-    @facthandler.expects(:find_facts).returns facts
-
-    @facthandler.facts_for_uploading.should == {:facts_format => :b64_zlib_yaml, :facts => text}
+    @facthandler.facts_for_uploading.should == {:facts_format => :pson, :facts => text}
   end
 
   it "should properly accept facts containing a '+'" do
-    facts = stub 'facts'
-    facts.expects(:support_format?).with(:b64_zlib_yaml).returns true
-    facts.expects(:render).returns "my+text"
-    text = "my%2Btext"
-
-    @facthandler.expects(:find_facts).returns facts
-
-    @facthandler.facts_for_uploading.should == {:facts_format => :b64_zlib_yaml, :facts => text}
-  end
-
-  it "use compressed yaml as the serialization if zlib is supported" do
-    facts = stub 'facts'
-    facts.expects(:support_format?).with(:b64_zlib_yaml).returns true
-    facts.expects(:render).with(:b64_zlib_yaml).returns "my text"
-    text = CGI.escape("my text")
-
-    @facthandler.expects(:find_facts).returns facts
-
-    @facthandler.facts_for_uploading
-  end
-
-  it "should use yaml as the serialization if zlib is not supported" do
-    facts = stub 'facts'
-    facts.expects(:support_format?).with(:b64_zlib_yaml).returns false
-    facts.expects(:render).with(:yaml).returns "my text"
-    text = CGI.escape("my text")
-
-    @facthandler.expects(:find_facts).returns facts
+    facts = Puppet::Node::Facts.new('foo', 'afact' => 'a+b')
+    Puppet::Node::Facts.indirection.save(facts)
+    text = CGI.escape(@facthandler.find_facts.render(:pson))
 
-    @facthandler.facts_for_uploading
+    @facthandler.facts_for_uploading.should == {:facts_format => :pson, :facts => text}
   end
 end

data/spec/unit/configurer_spec.rb

@@ -104,7 +104,7 @@ describe Puppet::Configurer do
       @agent.run(:pluginsync => false)
     end
 
-    it "should carry on when it can't fetch it's node definition" do
+    it "should carry on when it can't fetch its node definition" do
       error = Net::HTTPError.new(400, 'dummy server communication error')
       Puppet::Node.indirection.expects(:find).raises(error)
       @agent.run.should == 0
@@ -137,20 +137,17 @@ describe Puppet::Configurer do
 
     it "should use the provided report if it was passed one" do
       report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).never
-      @catalog.expects(:apply).with{|options| options[:report] == report}
+      @catalog.expects(:apply).with {|options| options[:report] == report}
 
       @agent.run(:report => report)
     end
 
     it "should set the report as a log destination" do
       report = Puppet::Transaction::Report.new("apply")
-      Puppet::Transaction::Report.expects(:new).returns report
 
-      Puppet::Util::Log.expects(:newdestination).with(report)
-      Puppet::Util::Log.expects(:close).with(report)
+      report.expects(:<<).with(instance_of(Puppet::Util::Log)).at_least_once
 
-      @agent.run
+      @agent.run(:report => report)
     end
 
     it "should retrieve the catalog" do
@@ -480,6 +477,25 @@ describe Puppet::Configurer do
       Puppet.expects(:err)
       expect { @configurer.save_last_run_summary(@report) }.to_not raise_error
     end
+
+    it "should create the last run file with the correct mode" do
+      Puppet.settings.setting(:lastrunfile).expects(:mode).returns('664')
+      @configurer.save_last_run_summary(@report)
+
+      if Puppet::Util::Platform.windows?
+        require 'puppet/util/windows/security'
+        mode = Puppet::Util::Windows::Security.get_mode(Puppet[:lastrunfile])
+      else
+        mode = File.stat(Puppet[:lastrunfile]).mode
+      end
+      (mode & 0777).should == 0664
+    end
+
+    it "should report invalid last run file permissions" do
+      Puppet.settings.setting(:lastrunfile).expects(:mode).returns('892')
+      Puppet.expects(:err).with(regexp_matches(/Could not save last run local report.*892 is invalid/))
+      @configurer.save_last_run_summary(@report)
+    end
   end
 
   describe "when retrieving a catalog" do

data/spec/unit/daemon_spec.rb

@@ -19,24 +19,29 @@ end
 describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
-  before do
-    # Forking agent not needed here
-    @agent = Puppet::Agent.new(TestClient.new, false)
-    @daemon = Puppet::Daemon.new
-    @daemon.stubs(:close_streams).returns nil
-  end
+  class RecordingScheduler
+    attr_reader :jobs
 
-  it "should be able to manage an agent" do
-    @daemon.should respond_to(:agent)
+    def run_loop(jobs)
+      @jobs = jobs
+    end
   end
 
-  it "should be able to manage a network server" do
-    @daemon.should respond_to(:server)
+  let(:server) { stub("Server", :start => nil, :wait_for_shutdown => nil) }
+  let(:agent) { Puppet::Agent.new(TestClient.new, false) }
+
+  let(:pidfile) { stub("PidFile", :lock => true, :unlock => true, :file_path => 'fake.pid') }
+  let(:scheduler) { RecordingScheduler.new }
+
+  let(:daemon) { Puppet::Daemon.new(pidfile, scheduler) }
+
+  before do
+    daemon.stubs(:close_streams).returns nil
   end
 
   it "should reopen the Log logs when told to reopen logs" do
     Puppet::Util::Log.expects(:reopen)
-    @daemon.reopen_logs
+    daemon.reopen_logs
   end
 
   let(:server) { stub("Server", :start => nil, :wait_for_shutdown => nil) }
@@ -50,52 +55,81 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
 
         Puppet.expects(:notice)
 
-        @daemon.expects(method)
+        daemon.expects(method)
 
-        @daemon.set_signal_traps
+        daemon.set_signal_traps
       end
     end
   end
 
   describe "when starting" do
     before do
-      @daemon.stubs(:create_pidfile)
-      @daemon.stubs(:set_signal_traps)
-      @daemon.stubs(:run_event_loop)
+      daemon.stubs(:set_signal_traps)
     end
 
     it "should fail if it has neither agent nor server" do
-      lambda { @daemon.start }.should raise_error(Puppet::DevError)
+      expect { daemon.start }.to raise_error(Puppet::DevError)
     end
 
     it "should create its pidfile" do
-      @daemon.agent = @agent
+      pidfile.expects(:lock).returns(true)
 
-      @daemon.expects(:create_pidfile)
-      @daemon.start
+      daemon.agent = agent
+      daemon.start
+    end
+
+    it "should fail if it cannot lock" do
+      pidfile.expects(:lock).returns(false)
+      daemon.agent = agent
+
+      expect { daemon.start }.to raise_error(RuntimeError, "Could not create PID file: #{pidfile.file_path}")
     end
 
     it "should start its server if one is configured" do
-      @daemon.server = server
+      daemon.server = server
 
       server.expects(:start)
-      @daemon.stubs(:server).returns server
 
-      @daemon.start
+      daemon.start
+    end
+
+    it "disables the reparse of configs if the filetimeout is 0" do
+      Puppet[:filetimeout] = 0
+      daemon.agent = agent
+
+      daemon.start
+
+      scheduler.jobs[0].should_not be_enabled
+    end
+
+    it "disables the agent run when there is no agent" do
+      Puppet[:filetimeout] = 0
+      daemon.server = server
+
+      daemon.start
+
+      scheduler.jobs[1].should_not be_enabled
+    end
+
+    it "waits for the server to shutdown when there is one" do
+      daemon.server = server
+
+      server.expects(:wait_for_shutdown)
+
+      daemon.start
     end
 
     it "waits for the server to shutdown when there is one" do
-      @daemon.server = server
+      daemon.server = server
 
       server.expects(:wait_for_shutdown)
 
-      @daemon.start
+      daemon.start
     end
   end
 
   describe "when stopping" do
     before do
-      @daemon.stubs(:remove_pidfile)
       Puppet::Util::Log.stubs(:close_all)
       # to make the global safe to mock, set it to a subclass of itself,
       # then restore it in an after pass
@@ -109,115 +143,57 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
 
     it "should stop its server if one is configured" do
       server.expects(:stop)
-      @daemon.stubs(:server).returns server
-      expect { @daemon.stop }.to exit_with 0
+
+      daemon.server = server
+
+      expect { daemon.stop }.to exit_with 0
     end
 
     it 'should request a stop from Puppet::Application' do
       Puppet::Application.expects(:stop!)
-      expect { @daemon.stop }.to exit_with 0
+      expect { daemon.stop }.to exit_with 0
     end
 
     it "should remove its pidfile" do
-      @daemon.expects(:remove_pidfile)
-      expect { @daemon.stop }.to exit_with 0
+      pidfile.expects(:unlock)
+
+      expect { daemon.stop }.to exit_with 0
     end
 
     it "should close all logs" do
       Puppet::Util::Log.expects(:close_all)
-      expect { @daemon.stop }.to exit_with 0
+      expect { daemon.stop }.to exit_with 0
     end
 
     it "should exit unless called with ':exit => false'" do
-      expect { @daemon.stop }.to exit_with 0
+      expect { daemon.stop }.to exit_with 0
     end
 
     it "should not exit if called with ':exit => false'" do
-      @daemon.stop :exit => false
-    end
-  end
-
-  describe "when creating its pidfile" do
-    it "should use an exclusive mutex" do
-      Puppet.run_mode.expects(:name).returns "me"
-      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
-      @daemon.create_pidfile
-    end
-
-    it "should lock the pidfile using the Pidlock class" do
-      pidfile = mock 'pidfile'
-
-      Puppet.run_mode.expects(:name).returns "eh"
-      Puppet[:pidfile] = make_absolute("/my/file")
-
-      Puppet::Util::Pidlock.expects(:new).with(make_absolute("/my/file")).returns pidfile
-
-      pidfile.expects(:lock).returns true
-      @daemon.create_pidfile
-    end
-
-    it "should fail if it cannot lock" do
-      pidfile = mock 'pidfile'
-
-      Puppet.run_mode.expects(:name).returns "eh"
-      Puppet[:pidfile] = make_absolute("/my/file")
-
-      Puppet::Util::Pidlock.expects(:new).with(make_absolute("/my/file")).returns pidfile
-
-      pidfile.expects(:lock).returns false
-
-      lambda { @daemon.create_pidfile }.should raise_error
-    end
-  end
-
-  describe "when removing its pidfile" do
-    it "should use an exclusive mutex" do
-      Puppet.run_mode.expects(:name).returns "me"
-
-      Puppet::Util.expects(:synchronize_on).with("me",Sync::EX)
-
-      @daemon.remove_pidfile
-    end
-
-    it "should do nothing if the pidfile is not present" do
-      pidfile = mock 'pidfile', :unlock => false
-
-      Puppet[:pidfile] = make_absolute("/my/file")
-      Puppet::Util::Pidlock.expects(:new).with(make_absolute("/my/file")).returns pidfile
-
-      @daemon.remove_pidfile
-    end
-
-    it "should unlock the pidfile using the Pidlock class" do
-      pidfile = mock 'pidfile', :unlock => true
-
-      Puppet[:pidfile] = make_absolute("/my/file")
-      Puppet::Util::Pidlock.expects(:new).with(make_absolute("/my/file")).returns pidfile
-
-      @daemon.remove_pidfile
+      daemon.stop :exit => false
     end
   end
 
   describe "when reloading" do
     it "should do nothing if no agent is configured" do
-      @daemon.reload
+      daemon.reload
     end
 
     it "should do nothing if the agent is running" do
-      @agent.expects(:running?).returns true
+      agent.expects(:running?).returns true
 
-      @daemon.agent = @agent
+      daemon.agent = agent
 
-      @daemon.reload
+      daemon.reload
     end
 
     it "should run the agent if one is available and it is not running" do
-      @agent.expects(:running?).returns false
-      @agent.expects(:run).with({:splay => false})
+      agent.expects(:running?).returns false
+      agent.expects(:run).with({:splay => false})
 
-      @daemon.agent = @agent
+      daemon.agent = agent
 
-      @daemon.reload
+      daemon.reload
     end
   end
 
@@ -232,48 +208,48 @@ describe Puppet::Daemon, :unless => Puppet.features.microsoft_windows? do
 
     it 'should set Puppet::Application.restart!' do
       Puppet::Application.expects(:restart!)
-      @daemon.stubs(:reexec)
-      @daemon.restart
+      daemon.stubs(:reexec)
+      daemon.restart
     end
 
     it "should reexec itself if no agent is available" do
-      @daemon.expects(:reexec)
+      daemon.expects(:reexec)
 
-      @daemon.restart
+      daemon.restart
     end
 
     it "should reexec itself if the agent is not running" do
-      @agent.expects(:running?).returns false
-      @daemon.agent = @agent
-      @daemon.expects(:reexec)
+      agent.expects(:running?).returns false
+      daemon.agent = agent
+      daemon.expects(:reexec)
 
-      @daemon.restart
+      daemon.restart
     end
   end
 
   describe "when reexecing it self" do
     before do
-      @daemon.stubs(:exec)
-      @daemon.stubs(:stop)
+      daemon.stubs(:exec)
+      daemon.stubs(:stop)
     end
 
     it "should fail if no argv values are available" do
-      @daemon.expects(:argv).returns nil
-      lambda { @daemon.reexec }.should raise_error(Puppet::DevError)
+      daemon.expects(:argv).returns nil
+      lambda { daemon.reexec }.should raise_error(Puppet::DevError)
     end
 
     it "should shut down without exiting" do
-      @daemon.argv = %w{foo}
-      @daemon.expects(:stop).with(:exit => false)
+      daemon.argv = %w{foo}
+      daemon.expects(:stop).with(:exit => false)
 
-      @daemon.reexec
+      daemon.reexec
     end
 
     it "should call 'exec' with the original executable and arguments" do
-      @daemon.argv = %w{foo}
-      @daemon.expects(:exec).with($0 + " foo")
+      daemon.argv = %w{foo}
+      daemon.expects(:exec).with($0 + " foo")
 
-      @daemon.reexec
+      daemon.reexec
     end
   end
 end