puppet 2.7.11 → 2.7.12

data/spec/unit/agent_spec.rb

@@ -24,7 +24,6 @@ describe Puppet::Agent do
 
     # So we don't actually try to hit the filesystem.
     @agent.stubs(:lock).yields
-    @agent.stubs(:disabled?).returns(false)
 
     # make Puppet::Application safe for stubbing; restore in an :after block; silence warnings for this.
     without_warnings { Puppet::Application = Class.new(Puppet::Application) }
@@ -58,6 +57,7 @@ describe Puppet::Agent do
     client.expects(:run)
 
     @agent.stubs(:running?).returns false
+    @agent.stubs(:disabled?).returns false
     @agent.run
   end
 
@@ -66,24 +66,34 @@ describe Puppet::Agent do
     @agent.lockfile_path.should == "/my/lock"
   end
 
-  it "should be considered running if the lock file is locked" do
+  it "should be considered running if the lock file is locked and not anonymous" do
     lockfile = mock 'lockfile'
 
-    @agent.expects(:lockfile).returns lockfile
+    @agent.expects(:lockfile).returns(lockfile).twice
     lockfile.expects(:locked?).returns true
+    lockfile.expects(:anonymous?).returns false
 
     @agent.should be_running
   end
 
+  it "should be considered disabled if the lock file is locked and anonymous" do
+    lockfile = mock 'lockfile'
+
+    @agent.expects(:lockfile).returns(lockfile).at_least_once
+    lockfile.expects(:locked?).returns(true).at_least_once
+    lockfile.expects(:anonymous?).returns(true).at_least_once
+
+    @agent.should be_disabled
+  end
+
   describe "when being run" do
     before do
-      AgentTestClient.stubs(:lockfile_path).returns "/my/lock"
       @agent.stubs(:running?).returns false
+      @agent.stubs(:disabled?).returns false
     end
 
     it "should splay" do
       @agent.expects(:splay)
-      @agent.stubs(:running?).returns false
 
       @agent.run
     end
@@ -94,9 +104,19 @@ describe Puppet::Agent do
       @agent.run
     end
 
-    it "should do nothing if disabled" do
-      @agent.expects(:disabled?).returns(true)
-      AgentTestClient.expects(:new).never
+    it "(#11057) should notify the user about why a run is skipped" do
+      Puppet::Application.stubs(:controlled_run).returns(false)
+      Puppet::Application.stubs(:run_status).returns('MOCK_RUN_STATUS')
+      # This is the actual test that we inform the user why the run is skipped.
+      # We assume this information is contained in
+      # Puppet::Application.run_status
+      Puppet.expects(:notice).with(regexp_matches(/MOCK_RUN_STATUS/))
+      @agent.run
+    end
+
+    it "should display an informative message if the agent is administratively disabled" do
+      @agent.expects(:disabled?).returns true
+      Puppet.expects(:notice).with(regexp_matches(/Skipping run of .*; administratively disabled/))
       @agent.run
     end
 

data/spec/unit/application/agent_spec.rb

@@ -91,7 +91,7 @@ describe Puppet::Application::Agent do
       @puppetd.command_line.stubs(:args).returns([])
     end
 
-    [:centrallogging, :enable, :debug, :fqdn, :test, :verbose, :digest].each do |option|
+    [:centrallogging, :disable, :enable, :debug, :fqdn, :test, :verbose, :digest].each do |option|
       it "should declare handle_#{option} method" do
         @puppetd.should respond_to("handle_#{option}".to_sym)
       end
@@ -102,24 +102,6 @@ describe Puppet::Application::Agent do
       end
     end
 
-    describe "when handling --disable" do
-      it "should declare handle_disable method" do
-        @puppetd.should respond_to(:handle_disable)
-      end
-
-      it "should set disable to true" do
-        @puppetd.options.stubs(:[]=)
-        @puppetd.options.expects(:[]=).with(:disable, true)
-        @puppetd.handle_disable('')
-      end
-
-      it "should store disable message" do
-        @puppetd.options.stubs(:[]=)
-        @puppetd.options.expects(:[]=).with(:disable_message, "message")
-        @puppetd.handle_disable('message')
-      end
-    end
-
     it "should set an existing handler on server" do
       Puppet::Network::Handler.stubs(:handler).with("handler").returns(true)
 
@@ -260,10 +242,10 @@ describe Puppet::Application::Agent do
         end
       end
 
-      it "should set syslog as the log destination if no --logdest" do
+      it "should set a default log destination if no --logdest" do
         @puppetd.options.stubs(:[]).with(:setdest).returns(false)
 
-        Puppet::Util::Log.expects(:newdestination).with(:syslog)
+        Puppet::Util::Log.expects(:setup_default)
 
         @puppetd.setup_logs
       end
@@ -286,7 +268,7 @@ describe Puppet::Application::Agent do
     it "should set a central log destination with --centrallogs" do
       @puppetd.options.stubs(:[]).with(:centrallogs).returns(true)
       Puppet[:server] = "puppet.reductivelabs.com"
-      Puppet::Util::Log.stubs(:newdestination).with(:syslog)
+      Puppet::Util::Log.stubs(:setup_default)
 
       Puppet::Util::Log.expects(:newdestination).with("puppet.reductivelabs.com")
 
@@ -367,20 +349,6 @@ describe Puppet::Application::Agent do
         end
       end
 
-      it "should pass the disable message when disabling" do
-        @puppetd.options.stubs(:[]).with(:disable).returns(true)
-        @puppetd.options.stubs(:[]).with(:disable_message).returns("message")
-        @agent.expects(:disable).with("message")
-        expect { @puppetd.enable_disable_client(@agent) }.to exit_with 0
-      end
-
-      it "should pass the default disable message when disabling without a message" do
-        @puppetd.options.stubs(:[]).with(:disable).returns(true)
-        @puppetd.options.stubs(:[]).with(:disable_message).returns(nil)
-        @agent.expects(:disable).with("reason not specified")
-        expect { @puppetd.enable_disable_client(@agent) }.to exit_with 0
-      end
-
       it "should finally exit" do
         expect { @puppetd.enable_disable_client(@agent) }.to exit_with 0
       end

data/spec/unit/application/device_spec.rb

@@ -163,10 +163,10 @@ describe Puppet::Application::Device do
         end
       end
 
-      it "should set syslog as the log destination if no --logdest" do
+      it "should set a default log destination if no --logdest" do
         @device.options.stubs(:[]).with(:setdest).returns(false)
 
-        Puppet::Util::Log.expects(:newdestination).with(:syslog)
+        Puppet::Util::Log.expects(:setup_default)
 
         @device.setup_logs
       end
@@ -320,22 +320,67 @@ describe Puppet::Application::Device do
 
       [:vardir, :confdir].each do |setting|
         it "should cleanup the #{setting} setting after the run" do
-          configurer = states('configurer').starts_as('notrun')
-          Puppet.settings.expects(:set_value).with(setting, make_absolute("/dummy/devices/device1"), :cli).when(configurer.is('notrun'))
-          @configurer.expects(:run).twice.then(configurer.is('run'))
-          Puppet.settings.expects(:set_value).with(setting, make_absolute("/dummy"), :cli).when(configurer.is('run'))
+          all_devices = Set.new(@device_hash.keys.map do |device_name| make_absolute("/dummy/devices/#{device_name}") end)
+          found_devices = Set.new()
+
+          # a block to use in a few places later to validate the arguments passed to "set_value"
+          p = Proc.new do |my_setting, my_value, my_type|
+            success =
+                  (my_setting == setting) &&
+                    (my_type == :cli) &&
+                    (all_devices.include?(my_value))
+                found_devices.add(my_value) if success
+                success
+          end
+
+          seq = sequence("clean up dirs")
+
+          all_devices.size.times do
+            ## one occurrence of set / run / set("/dummy") for each device
+            Puppet.settings.expects(:set_value).with(&p).in_sequence(seq)
+            @configurer.expects(:run).in_sequence(seq)
+            Puppet.settings.expects(:set_value).with(setting, make_absolute("/dummy"), :cli).in_sequence(seq)
+          end
+
 
           @device.main
+
+          # make sure that we were called with each of the defined devices
+          all_devices.should == found_devices
+
         end
       end
 
       it "should cleanup the certname setting after the run" do
-        configurer = states('configurer').starts_as('notrun')
-        Puppet.settings.expects(:set_value).with(:certname, "device1", :cli).when(configurer.is('notrun'))
-        @configurer.expects(:run).twice.then(configurer.is('run'))
-        Puppet.settings.expects(:set_value).with(:certname, "certname", :cli).when(configurer.is('run'))
+        all_devices = Set.new(@device_hash.keys)
+        found_devices = Set.new()
+
+        # a block to use in a few places later to validate the arguments passed to "set_value"
+        p = Proc.new do |my_setting, my_value, my_type|
+          success =
+              (my_setting == :certname) &&
+                  (my_type == :cli) &&
+                  (all_devices.include?(my_value))
+          found_devices.add(my_value) if success
+          success
+          #true
+        end
+
+        seq = sequence("clean up certname")
+
+        all_devices.size.times do
+          ## one occurrence of set / run / set("certname") for each device
+          Puppet.settings.expects(:set_value).with(&p).in_sequence(seq)
+          @configurer.expects(:run).in_sequence(seq)
+          Puppet.settings.expects(:set_value).with(:certname, "certname", :cli).in_sequence(seq)
+        end
+
 
         @device.main
+
+        # make sure that we were called with each of the defined devices
+        all_devices.should == found_devices
+
       end
 
       it "should expire all cached attributes" do

data/spec/unit/application/face_base_spec.rb

@@ -224,7 +224,7 @@ describe Puppet::Application::FaceBase do
     end
 
     it "should use its render method to render any result" do
-      app.expects(:render).with(app.arguments.length + 1)
+      app.expects(:render).with(app.arguments.length + 1, ["myname", "myarg"])
       expect { app.main }.to exit_with 0
     end
   end
@@ -257,6 +257,11 @@ describe Puppet::Application::FaceBase do
       app.action = app.face.get_action :return_raise
       expect { app.main }.not_to exit_with 0
     end
+
+    it "should use the exit code set by the action" do
+      app.action = app.face.get_action :with_specific_exit_code
+      expect { app.main }.to exit_with 5
+    end
   end
 
   describe "#render" do
@@ -270,19 +275,19 @@ describe Puppet::Application::FaceBase do
 
       ["hello", 1, 1.0].each do |input|
         it "should just return a #{input.class.name}" do
-          app.render(input).should == input
+          app.render(input, {}).should == input
         end
       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
+          app.render(input, {}).should == input.to_pson.chomp
         end
       end
 
       it "should render a non-trivially-keyed Hash with using JSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
-        app.render(hash).should == hash.to_pson.chomp
+        app.render(hash, {}).should == hash.to_pson.chomp
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
@@ -292,7 +297,7 @@ describe Puppet::Application::FaceBase do
 
         # Gotta love ASCII-betical sort order.  Hope your objects are better
         # structured for display than my test one is. --daniel 2011-04-18
-        app.render(hash).should == <<EOT
+        app.render(hash, {}).should == <<EOT
 5      5
 6.0    6
 four   #{object.to_pson.chomp}
@@ -308,7 +313,7 @@ EOT
           "number" => { "1" => '1' * 40, "2" => '2' * 40, '3' => '3' * 40 },
           "text"   => { "a" => 'a' * 40, 'b' => 'b' * 40, 'c' => 'c' * 40 }
         }
-        app.render(hash).should == <<EOT
+        app.render(hash, {}).should == <<EOT
 number  {"1"=>"1111111111111111111111111111111111111111",
          "2"=>"2222222222222222222222222222222222222222",
          "3"=>"3333333333333333333333333333333333333333"}
@@ -318,14 +323,31 @@ text    {"a"=>"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
 EOT
       end
 
-      it "should invoke the action rendering hook while rendering" do
-        app.action.set_rendering_method_for(:console, proc { |value| "bi-winning!" })
-        app.render("bi-polar?").should == "bi-winning!"
+      describe "when setting the rendering method" do
+        after do
+          # need to reset the when_rendering block so that other tests can set it later
+          app.action.instance_variable_set("@when_rendering", {})
+        end
+
+        it "should invoke the action rendering hook while rendering" do
+          app.action.set_rendering_method_for(:console, proc { |value| "bi-winning!" })
+          app.render("bi-polar?", {}).should == "bi-winning!"
+        end
+
+        it "should invoke the action rendering hook with args and options while rendering" do
+          app.action.instance_variable_set("@when_rendering", {})
+          app.action.when_invoked = proc { |name, options| 'just need to match arity for rendering' }
+          app.action.set_rendering_method_for(
+            :console,
+            proc { |value, name, options| "I'm #{name}, no wait, I'm #{options[:altername]}" }
+          )
+          app.render("bi-polar?", ['bob', {:altername => 'sue'}]).should == "I'm bob, no wait, I'm sue"
+        end
       end
 
       it "should render JSON when asked for json" do
         app.render_as = :json
-        json = app.render({ :one => 1, :two => 2 })
+        json = app.render({ :one => 1, :two => 2 }, {})
         json.should =~ /"one":\s*1\b/
         json.should =~ /"two":\s*2\b/
         PSON.parse(json).should == { "one" => 1, "two" => 2 }

data/spec/unit/application/filebucket_spec.rb

@@ -182,6 +182,11 @@ describe Puppet::Application::Filebucket do
     end
 
     describe "the command backup" do
+      it "should fail if no arguments are specified" do
+        @filebucket.stubs(:args).returns([])
+        lambda { @filebucket.backup }.should raise_error
+      end
+
       it "should call the client backup method for each given parameter" do
         @filebucket.stubs(:puts)
         FileTest.stubs(:exists?).returns(true)

data/spec/unit/application/kick_spec.rb

@@ -126,6 +126,12 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
       @kick.options.stubs(:[]).with(any_parameters)
     end
 
+    it "should abort stating that kick is not supported on Windows" do
+      Puppet.features.stubs(:microsoft_windows?).returns(true)
+
+      expect { @kick.setup }.to raise_error(Puppet::Error, /Puppet kick is not supported on Microsoft Windows/)
+    end
+
     it "should set log level to debug if --debug was passed" do
       @kick.options.stubs(:[]).with(:debug).returns(true)
       @kick.setup

data/spec/unit/application_spec.rb

@@ -38,6 +38,12 @@ describe Puppet::Application do
 
       expect { @klass.find("ThisShallNeverEverEverExist") }.to exit_with 1
     end
+
+    it "#12114: should prevent File namespace collisions" do
+      # have to require the file face once, then the second time around it would fail
+      @klass.find("File").should == Puppet::Application::File
+      @klass.find("File").should == Puppet::Application::File
+    end
   end
 
   describe ".run_mode" do
@@ -62,6 +68,7 @@ describe Puppet::Application do
       end
     end
 
+    Puppet.features.stubs(:syslog?).returns(true)
     Puppet[:run_mode].should == "user"
 
     expect {
@@ -384,7 +391,7 @@ describe Puppet::Application do
     it "should honor setdest option" do
       @app.options.stubs(:[]).with(:setdest).returns(false)
 
-      Puppet::Util::Log.expects(:newdestination).with(:syslog)
+      Puppet::Util::Log.expects(:setup_default)
 
       @app.setup
     end

data/spec/unit/configurer/downloader_spec.rb

@@ -79,14 +79,13 @@ describe Puppet::Configurer::Downloader do
     end
 
     describe "on Windows", :if => Puppet.features.microsoft_windows? do
-      it "should always set the owner to the current user" do
-        Sys::Admin.expects(:get_login).returns 'foo'
-        Puppet::Type.type(:file).expects(:new).with { |opts| opts[:owner] == 'foo' }
+      it "should omit the owner" do
+        Puppet::Type.type(:file).expects(:new).with { |opts| opts[:owner] == nil }
         @dler.file
       end
 
-      it "should always set the group to nobody" do
-        Puppet::Type.type(:file).expects(:new).with { |opts| opts[:group] == 'S-1-0-0' }
+      it "should omit the group" do
+        Puppet::Type.type(:file).expects(:new).with { |opts| opts[:group] == nil }
         @dler.file
       end
     end

data/spec/unit/face/ca_spec.rb

@@ -312,16 +312,27 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
     end
 
     context "with no hosts in CA" do
-      [:pending, :signed, :all].each do |type|
-        it "should return nothing for #{type}" do
-          subject.list(type => true).should == []
+      [
+        {},
+        { :pending => true },
+        { :signed => true },
+        { :all => true },
+      ].each do |type|
+        it "should return nothing for #{type.inspect}" do
+          subject.list(type).should == []
         end
 
         it "should not fail when a matcher is passed" do
           expect {
-            subject.list(type => true, :subject => '.').should == []
+            subject.list(type.merge :subject => '.').should == []
           }.should_not raise_error
         end
+
+        context "when_rendering :console" do
+          it "should return nothing for #{type.inspect}" do
+            action.when_rendering(:console).call(subject.list(type)).should == ""
+          end
+        end
       end
     end
 

data/spec/unit/file_bucket/dipper_spec.rb

@@ -123,7 +123,7 @@ describe Puppet::FileBucket::Dipper do
         klass.any_instance.expects(:find).with { |r| request = r }.returns(Puppet::FileBucket::File.new(contents))
 
         dipper.restore(dest, md5).should == md5
-        Digest::MD5.hexdigest(Puppet::Util.binread(dest)).should == md5
+        Digest::MD5.hexdigest(IO.binread(dest)).should == md5
 
         request.key.should == "md5/#{md5}"
         request.server.should == server