puppet 2.7.26 → 3.0.0.rc4

data/spec/unit/application/inspect_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/application/inspect'
@@ -260,7 +260,8 @@ describe Puppet::Application::Inspect do
         event.property.should == "content"
         event.status.should == "failure"
         event.audited.should == true
-        event.instance_variables.should_not include("@previous_value")
+        event.instance_variables.should_not include "@previous_value"
+        event.instance_variables.should_not include :@previous_value
       end
 
       it "should continue to the next resource" do

data/spec/unit/application/kick_spec.rb

@@ -1,12 +1,12 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/application/kick'
-require 'puppet/run'
-require 'puppet/util/ldap/connection'
 
 describe Puppet::Application::Kick, :if => Puppet.features.posix? do
+
   before :each do
+    require 'puppet/util/ldap/connection'
     Puppet::Util::Ldap::Connection.stubs(:new).returns(stub_everything)
     @kick = Puppet::Application[:kick]
     Puppet::Util::Log.stubs(:newdestination)
@@ -19,10 +19,6 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
     end
   end
 
-  it "should ask Puppet::Application to not parse Puppet configuration file" do
-    @kick.should_parse_config?.should be_false
-  end
-
   it "should declare a main command" do
     @kick.should respond_to(:main)
   end
@@ -121,7 +117,6 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
       @kick.hosts = []
       @kick.stubs(:trap)
       @kick.stubs(:puts)
-      Puppet.stubs(:parse_config)
 
       @kick.options.stubs(:[]).with(any_parameters)
     end
@@ -144,15 +139,9 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
       Puppet::Log.level.should == :info
     end
 
-    it "should Parse puppet config" do
-      Puppet.expects(:parse_config)
-
-      @kick.setup
-    end
-
     describe "when using the ldap node terminus" do
       before :each do
-        Puppet.stubs(:[]).with(:node_terminus).returns("ldap")
+        Puppet[:node_terminus] = "ldap"
       end
 
       it "should pass the fqdn option to search" do
@@ -227,9 +216,6 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
         @kick.options.stubs(:[]).with(:ignoreschedules).returns(false)
         @kick.options.stubs(:[]).with(:foreground).returns(false)
         @kick.options.stubs(:[]).with(:debug).returns(false)
-        @kick.options.stubs(:[]).with(:verbose).returns(false) # needed when logging is initialized
-        @kick.options.stubs(:[]).with(:setdest).returns(false) # needed when logging is initialized
-
         @kick.stubs(:print)
         @kick.preinit
         @kick.stubs(:parse_options)
@@ -259,6 +245,7 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
 
       describe "during call of run_for_host" do
         before do
+          require 'puppet/run'
           options = {
             :background => true, :ignoreschedules => false, :tags => []
           }
@@ -266,16 +253,13 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
           @agent_run = Puppet::Run.new( options.dup )
           @agent_run.stubs(:status).returns("success")
 
-          # ensure that we don't actually run the agent
-          @agent_run.stubs(:run).returns(@agent_run)
-
-          Puppet::Run.indirection.terminus_class = :local
           Puppet::Run.indirection.expects(:terminus_class=).with( :rest )
           Puppet::Run.expects(:new).with( options ).returns(@agent_run)
         end
 
         it "should call run on a Puppet::Run for the given host" do
           Puppet::Run.indirection.expects(:save).with(@agent_run, 'https://host:8139/production/run/host').returns(@agent_run)
+
           expect { @kick.run_for_host('host') }.to exit_with 0
         end
 

data/spec/unit/application/master_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/application/master'
@@ -25,10 +25,6 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
     @master.class.run_mode.name.should equal(:master)
   end
 
-  it "should ask Puppet::Application to parse Puppet configuration file" do
-    @master.should_parse_config?.should be_true
-  end
-
   it "should declare a main command" do
     @master.should respond_to(:main)
   end
@@ -103,6 +99,17 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
 
       @master.parse_options
     end
+
+    it "should support dns alt names from ARGV" do
+      Puppet.settings.initialize_global_settings(["--dns_alt_names", "foo,bar,baz"])
+
+      @master.preinit
+      @master.parse_options
+
+      Puppet[:dns_alt_names].should == "foo,bar,baz"
+    end
+
+
   end
 
   describe "during setup" do
@@ -173,12 +180,6 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
       @master.setup
     end
 
-    it "should cache class in yaml" do
-      Puppet::Node.indirection.expects(:cache_class=).with(:yaml)
-
-      @master.setup
-    end
-
     describe "with no ca" do
 
       it "should set the ca_location to none" do
@@ -238,8 +239,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
 
     describe "the compile command" do
       before do
-        Puppet.stubs(:[]).with(:environment)
-        Puppet.stubs(:[]).with(:manifest).returns("site.pp")
+        Puppet[:manifest] = "site.pp"
         Puppet.stubs(:err)
         @master.stubs(:jj)
         Puppet.features.stubs(:pson?).returns true
@@ -295,7 +295,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         Puppet::SSL::CertificateAuthority.stubs(:ca?)
         Process.stubs(:uid).returns(1000)
         Puppet.stubs(:service)
-        Puppet.stubs(:[])
+        Puppet[:daemonize] = false
         Puppet.stubs(:notice)
         Puppet.stubs(:start)
       end
@@ -312,19 +312,6 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
         @master.main
       end
 
-      it "should create the server with the right XMLRPC handlers" do
-        Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers] == [:Status, :FileServer, :Master, :Report, :Filebucket]}
-
-        @master.main
-      end
-
-      it "should create the server with a :ca xmlrpc handler if needed" do
-        Puppet.stubs(:[]).with(:ca).returns(true)
-        Puppet::Network::Server.expects(:new).with { |args| args[:xmlrpc_handlers].include?(:CA) }
-
-        @master.main
-      end
-
       it "should generate a SSL cert for localhost" do
         Puppet::SSL::Host.expects(:localhost)
 
@@ -348,7 +335,7 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
       end
 
       it "should daemonize if needed" do
-        Puppet.stubs(:[]).with(:daemonize).returns(true)
+        Puppet[:daemonize] = true
 
         @daemon.expects(:daemonize)
 
@@ -367,17 +354,6 @@ describe Puppet::Application::Master, :unless => Puppet.features.microsoft_windo
           Puppet::Network::HTTP::Rack.stubs(:new).returns(@app)
         end
 
-        it "it should create the app with REST and XMLRPC support" do
-          @master.options.stubs(:[]).with(:rack).returns(:true)
-
-          Puppet::Network::HTTP::Rack.expects(:new).with { |args|
-            args[:xmlrpc_handlers] == [:Status, :FileServer, :Master, :Report, :Filebucket] and
-            args[:protocols] == [:rest, :xmlrpc]
-          }
-
-          @master.main
-        end
-
         it "it should not start a daemon" do
           @master.options.stubs(:[]).with(:rack).returns(:true)
 

data/spec/unit/application/queue_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/application/queue'
@@ -14,10 +14,6 @@ describe Puppet::Application::Queue, :unless => Puppet.features.microsoft_window
     Puppet::Resource::Catalog.indirection.stubs(:terminus_class=)
   end
 
-  it "should ask Puppet::Application to parse Puppet configuration file" do
-    @queue.should_parse_config?.should be_true
-  end
-
   it "should declare a main command" do
     @queue.should respond_to(:main)
   end
@@ -136,7 +132,7 @@ describe Puppet::Application::Queue, :unless => Puppet.features.microsoft_window
     end
 
     it "should daemonize if needed" do
-      Puppet.expects(:[]).with(:daemonize).returns(true)
+      Puppet[:daemonize] = true
 
       @queue.daemon.expects(:daemonize)
 

data/spec/unit/application/resource_spec.rb

@@ -1,21 +1,18 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/application/resource'
 
 describe Puppet::Application::Resource do
+  include PuppetSpec::Files
   before :each do
     @resource_app = Puppet::Application[:resource]
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Resource.indirection.stubs(:terminus_class=)
   end
 
-  it "should ask Puppet::Application to not parse Puppet configuration file" do
-    @resource_app.should_parse_config?.should be_false
-  end
-
   describe "in preinit" do
-    it "should init extra_params to empty array", :'fails_on_ruby_1.9.2' => true do
+    it "should init extra_params to empty array" do
       @resource_app.preinit
       @resource_app.extra_params.should == []
     end
@@ -54,12 +51,23 @@ describe Puppet::Application::Resource do
 
       @resource_app.extra_params.should == [ :param1, :whatever ]
     end
+
+    it "should get a parameter in the printed data if extra_params are passed" do
+      tty  = stub("tty",  :tty? => true )
+      path = tmpfile('testfile')
+      command_line = Puppet::Util::CommandLine.new("puppet", [ 'resource', 'file', path ], tty )
+      @resource_app.stubs(:command_line).returns command_line
+
+      # provider is a parameter that should always be available
+      @resource_app.extra_params = [ :provider ]
+
+      expect { @resource_app.main }.to have_printed /provider\s+=>/
+    end
   end
 
   describe "during setup" do
     before :each do
       Puppet::Log.stubs(:newdestination)
-      Puppet.stubs(:parse_config)
     end
 
     it "should set console as the log destination" do
@@ -81,11 +89,6 @@ describe Puppet::Application::Resource do
       Puppet::Log.level.should == :info
     end
 
-    it "should Parse puppet config" do
-      Puppet.expects(:parse_config)
-
-      @resource_app.setup
-    end
   end
 
   describe "when running" do

data/spec/unit/application/secret_agent_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 require 'puppet/application/secret_agent'
 require 'puppet/indirector/catalog/rest'

data/spec/unit/application_spec.rb

@@ -1,20 +1,30 @@
-#!/usr/bin/env rspec
+#! /usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/application'
 require 'puppet'
 require 'getoptlong'
+require 'timeout'
 
 describe Puppet::Application do
 
-  before do
+  before(:each) do
     Puppet::Util::Instrumentation.stubs(:init)
     @app = Class.new(Puppet::Application).new
     @appclass = @app.class
 
     @app.stubs(:name).returns("test_app")
-    # avoid actually trying to parse any settings
-    Puppet.settings.stubs(:parse)
+
+  end
+
+  describe "application defaults" do
+    it "should fail if required app default values are missing" do
+      @app.stubs(:app_defaults).returns({ :foo => 'bar' })
+      Puppet.expects(:err).with(regexp_matches(/missing required app default setting/))
+      expect {
+        @app.run
+      }.to exit_with 1
+    end
   end
 
   describe "finding" do
@@ -27,18 +37,18 @@ describe Puppet::Application do
       @klass.find("Agent").should == @klass::Agent
     end
 
-    it "should not find classes outside the namespace", :'fails_on_ruby_1.9.2' => true do
-      expect { @klass.find("String") }.to exit_with 1
+    it "should not find classes outside the namespace" do
+      expect { @klass.find("String") }.to raise_error(LoadError)
     end
 
-    it "should exit if it can't find a class" do
-      @klass.expects(:puts).with do |value|
+    it "should error if it can't find a class" do
+      Puppet.expects(:err).with do |value|
         value =~ /Unable to find application 'ThisShallNeverEverEverExist'/ and
           value =~ /puppet\/application\/thisshallneverevereverexist/ and
           value =~ /no such file to load|cannot load such file/
       end
 
-      expect { @klass.find("ThisShallNeverEverEverExist") }.to exit_with 1
+      expect { @klass.find("ThisShallNeverEverEverExist") }.to raise_error(LoadError)
     end
 
     it "#12114: should prevent File namespace collisions" do
@@ -59,48 +69,73 @@ describe Puppet::Application do
     end
   end
 
-  it "should sadly and frighteningly allow run_mode to change at runtime" do
+
+
+  # These tests may look a little weird and repetative in its current state;
+  #  it used to illustrate several ways that the run_mode could be changed
+  #  at run time; there are fewer ways now, but it would still be nice to
+  #  get to a point where it was entirely impossible.
+  describe "when dealing with run_mode" 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"
+        # no-op
       end
     end
 
-    Puppet.features.stubs(:syslog?).returns(true)
-    Puppet[:run_mode].should == "user"
+    it "should sadly and frighteningly allow run_mode to change at runtime via #initialize_app_defaults" do
+      Puppet.features.stubs(:syslog?).returns(true)
+      Puppet[:run_mode].should == :user
 
-    expect {
-      app = TestApp.new
+      expect {
+        app = TestApp.new
+        app.initialize_app_defaults
 
-      Puppet[:run_mode].should == "master"
+        Puppet[:run_mode].should == :master
+      }.to_not raise_error
+    end
 
-      app.run
+    it "should sadly and frighteningly allow run_mode to change at runtime via #run" do
+      expect {
+        app = TestApp.new
+        app.run
 
-      app.class.run_mode.name.should == :agent
-      $puppet_application_mode.name.should == :agent
-    }.to_not raise_error
+        app.class.run_mode.name.should == :master
+
+        Puppet[:run_mode].should == :master
 
-    Puppet[:run_mode].should == "agent"
+      }.to_not raise_error
+
+    end
   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
+
+  it "it should not allow initialize_app_defaults to be called multiple times" do
     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
+      app.initialize_app_defaults
+    }.to_not raise_error
+
+    expect {
+      app.initialize_app_defaults
     }.to 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 explode when an invalid run mode is set at runtime, for great victory" do
+    class InvalidRunModeTestApp < Puppet::Application
+      run_mode :abracadabra
+      def run_command
+        # no-op
+      end
+    end
+
+    expect {
+      app = InvalidRunModeTestApp.new
+      app.initialize_app_defaults
+    }.to raise_error
+  end
 
   it "should have a run entry-point" do
     @app.should respond_to(:run)
@@ -127,9 +162,20 @@ describe Puppet::Application do
     @app.run_command
   end
 
-  it "should initialize the Puppet Instrumentation layer on creation" do
-    Puppet::Util::Instrumentation.expects(:init)
-    Class.new(Puppet::Application).new
+  it "should initialize the Puppet Instrumentation layer early in the life cycle" do
+    # Not proud of this, but the fact that we are stubbing init_app_defaults
+    #  below means that we will get errors if anyone tries to access any
+    #  settings that depend on app_defaults.  In general this whole test
+    #  seems to be testing too many implementation details rather than
+    #  functionality, but, hey.
+    Puppet[:route_file] = "/dev/null"
+
+    startup_sequence = sequence('startup')
+    @app.expects(:initialize_app_defaults).in_sequence(startup_sequence)
+    Puppet::Util::Instrumentation.expects(:init).in_sequence(startup_sequence)
+    @app.expects(:preinit).in_sequence(startup_sequence)
+
+    expect { @app.run }.to exit_with(1)
   end
 
   describe 'when invoking clear!' do
@@ -241,17 +287,28 @@ describe Puppet::Application do
     end
 
     describe 'on POSIX systems', :if => Puppet.features.posix? do
-      it 'should signal process with HUP after block if restart requested during block execution', :'fails_on_ruby_1.9.2' => true do
-        Puppet::Application.run_status = nil
-        target = mock 'target'
-        target.expects(:some_method).once
-        old_handler = trap('HUP') { target.some_method }
-        begin
-          Puppet::Application.controlled_run do
-            Puppet::Application.run_status = :restart_requested
+      it 'should signal process with HUP after block if restart requested during block execution' do
+        Timeout::timeout(3) do  # if the signal doesn't fire, this causes failure.
+
+          has_run = false
+          old_handler = trap('HUP') { has_run = true }
+
+          begin
+            Puppet::Application.controlled_run do
+              Puppet::Application.run_status = :restart_requested
+            end
+
+            # Ruby 1.9 uses a separate OS level thread to run the signal
+            # handler, so we have to poll - ideally, in a way that will kick
+            # the OS into running other threads - for a while.
+            #
+            # You can't just use the Ruby Thread yield thing either, because
+            # that is just an OS hint, and Linux ... doesn't take that
+            # seriously. --daniel 2012-03-22
+            sleep 0.001 while not has_run
+          ensure
+            trap('HUP', old_handler)
           end
-        ensure
-          trap('HUP', old_handler)
         end
       end
     end
@@ -282,19 +339,6 @@ describe Puppet::Application do
       @app.parse_options
     end
 
-    it "should get options from Puppet.settings.optparse_addargs" do
-      Puppet.settings.expects(:optparse_addargs).returns([])
-
-      @app.parse_options
-    end
-
-    it "should add Puppet.settings options to OptionParser" do
-      Puppet.settings.stubs(:optparse_addargs).returns( [["--option","-o", "Funny Option"]])
-      Puppet.settings.expects(:handlearg).with("--option", 'true')
-      @app.command_line.stubs(:args).returns(["--option"])
-      @app.parse_options
-    end
-
     it "should ask OptionParser to parse the command-line argument" do
       @app.command_line.stubs(:args).returns(%w{ fake args })
       OptionParser.any_instance.expects(:parse!).with(%w{ fake args })
@@ -331,44 +375,14 @@ describe Puppet::Application do
         @app.parse_options
       end
 
-      it "should pass it to Puppet.settings if handle_unknown says so" do
-        Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet", :REQUIRED]])
-
-        @app.stubs(:handle_unknown).with("--topuppet", "value").returns(false)
-
-        Puppet.settings.expects(:handlearg).with("--topuppet", "value")
-        @app.command_line.stubs(:args).returns(["--topuppet", "value"])
-        @app.parse_options
-      end
-
-      it "should pass it to Puppet.settings if there is no handle_unknown method" do
-        Puppet.settings.stubs(:optparse_addargs).returns([["--topuppet", :REQUIRED]])
-
-        @app.stubs(:respond_to?).returns(false)
-
-        Puppet.settings.expects(:handlearg).with("--topuppet", "value")
-        @app.command_line.stubs(:args).returns(["--topuppet", "value"])
-        @app.parse_options
-      end
-
-      it "should transform boolean false value to string for Puppet.settings" do
-        Puppet.settings.expects(:handlearg).with("--option", "false")
-        @app.handlearg("--option", false)
-      end
-
-      it "should transform boolean true value to string for Puppet.settings" do
-        Puppet.settings.expects(:handlearg).with("--option", "true")
-        @app.handlearg("--option", true)
-      end
-
       it "should transform boolean option to normal form for Puppet.settings" do
-        Puppet.settings.expects(:handlearg).with("--option", "true")
-        @app.handlearg("--[no-]option", true)
+        @app.expects(:handle_unknown).with("--option", true)
+        @app.send(:handlearg, "--[no-]option", true)
       end
 
       it "should transform boolean option to no- form for Puppet.settings" do
-        Puppet.settings.expects(:handlearg).with("--no-option", "false")
-        @app.handlearg("--[no-]option", false)
+        @app.expects(:handle_unknown).with("--no-option", false)
+        @app.send(:handlearg, "--[no-]option", false)
       end
 
     end
@@ -377,7 +391,6 @@ describe Puppet::Application do
   describe "when calling default setup" do
 
     before :each do
-      @app.stubs(:should_parse_config?).returns(false)
       @app.options.stubs(:[])
     end
 
@@ -480,32 +493,6 @@ describe Puppet::Application do
       @app.run
     end
 
-    it "should parse Puppet configuration if should_parse_config is called" do
-      @app.stubs(:run_command)
-      @app.class.should_parse_config
-
-      Puppet.settings.expects(:parse)
-
-      @app.run
-    end
-
-    it "should not parse_option if should_not_parse_config is called" do
-      @app.stubs(:run_command)
-      @app.class.should_not_parse_config
-
-      Puppet.settings.expects(:parse).never
-
-      @app.run
-    end
-
-    it "should parse Puppet configuration if needed" do
-      @app.stubs(:run_command)
-      @app.stubs(:should_parse_config?).returns(true)
-
-      Puppet.settings.expects(:parse)
-
-      @app.run
-    end
 
     it "should call run_command" do
       @app.expects(:run_command)
@@ -520,19 +507,19 @@ describe Puppet::Application do
     end
 
     it "should warn and exit if no command can be called" do
-      $stderr.expects(:puts)
+      Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns no command" do
       @app.stubs(:get_command).returns(nil)
-      $stderr.expects(:puts)
+      Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns an invalid command" do
       @app.stubs(:get_command).returns(:this_function_doesnt_exist)
-      $stderr.expects(:puts)
+      Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
   end