puppet 5.5.22-x86-mingw32 → 6.0.0-x86-mingw32

data/spec/unit/application_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/application'
@@ -6,11 +7,13 @@ require 'getoptlong'
 require 'timeout'
 
 describe Puppet::Application do
+
   before(:each) do
     @app = Class.new(Puppet::Application).new
     @appclass = @app.class
 
-    allow(@app).to receive(:name).and_return("test_app")
+    @app.stubs(:name).returns("test_app")
+
   end
 
   describe "application commandline" do
@@ -29,8 +32,8 @@ describe Puppet::Application do
 
   describe "application defaults" do
     it "should fail if required app default values are missing" do
-      allow(@app).to receive(:app_defaults).and_return({ :foo => 'bar' })
-      expect(Puppet).to receive(:err).with(/missing required app default setting/)
+      @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)
@@ -40,7 +43,7 @@ describe Puppet::Application do
   describe "finding" do
     before do
       @klass = Puppet::Application
-      allow(@klass).to receive(:puts)
+      @klass.stubs(:puts)
     end
 
     it "should find classes in the namespace" do
@@ -52,10 +55,10 @@ describe Puppet::Application do
     end
 
     it "should error if it can't find a class" do
-      expect(Puppet).to receive(:err) do |value|
-        expect(value).to match(/Unable to find application 'ThisShallNeverEverEverExist'/)
-        expect(value).to match(/puppet\/application\/thisshallneverevereverexist/)
-        expect(value).to match(/no such file to load|cannot load such file/)
+      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 {
@@ -67,22 +70,46 @@ describe Puppet::Application do
   describe "#available_application_names" do
     it 'should be able to find available application names' do
       apps =  %w{describe filebucket kick queue resource agent cert apply doc master}
-      expect(Puppet::Util::Autoload).to receive(:files_to_load).and_return(apps)
+      Puppet::Util::Autoload.expects(:files_to_load).returns(apps)
 
       expect(Puppet::Application.available_application_names).to match_array(apps)
     end
 
     it 'should find applications from multiple paths' do
-      expect(Puppet::Util::Autoload).to receive(:files_to_load).with('puppet/application').and_return(%w{ /a/foo.rb /b/bar.rb })
+      Puppet::Util::Autoload.expects(:files_to_load).with(
+        'puppet/application',
+        is_a(Puppet::Node::Environment)
+      ).returns(%w{ /a/foo.rb /b/bar.rb })
 
       expect(Puppet::Application.available_application_names).to match_array(%w{ foo bar })
     end
 
     it 'should return unique application names' do
-      expect(Puppet::Util::Autoload).to receive(:files_to_load).with('puppet/application').and_return(%w{ /a/foo.rb /b/foo.rb })
+      Puppet::Util::Autoload.expects(:files_to_load).with(
+        'puppet/application',
+        is_a(Puppet::Node::Environment)
+      ).returns(%w{ /a/foo.rb /b/foo.rb })
+
+      expect(Puppet::Application.available_application_names).to eq(%w{ foo })
+    end
+
+    it 'finds the application using the configured environment' do
+      Puppet[:environment] = 'production'
+      Puppet::Util::Autoload.expects(:files_to_load).with do |_, env|
+        expect(env.name).to eq(:production)
+      end.returns(%w{ /a/foo.rb })
 
       expect(Puppet::Application.available_application_names).to eq(%w{ foo })
     end
+
+    it "falls back to the current environment if the configured environment doesn't exist" do
+      Puppet[:environment] = 'doesnotexist'
+      Puppet::Util::Autoload.expects(:files_to_load).with do |_, env|
+        expect(env.name).to eq(:'*root*')
+      end.returns(%w[a/foo.rb])
+
+      expect(Puppet::Application.available_application_names).to eq(%w[foo])
+    end
   end
 
   describe ".run_mode" do
@@ -130,7 +157,7 @@ describe Puppet::Application do
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #initialize_app_defaults" do
-      allow(Puppet.features).to receive(:syslog?).and_return(true)
+      Puppet.features.stubs(:syslog?).returns(true)
 
       app = TestApp.new
       app.initialize_app_defaults
@@ -180,7 +207,7 @@ describe Puppet::Application do
   end
 
   it "should invoke main as the default" do
-    expect(@app).to receive(:main)
+    @app.expects( :main )
     @app.run_command
   end
 
@@ -276,8 +303,8 @@ describe Puppet::Application do
   describe 'when performing a controlled_run' do
     it 'should not execute block if not :clear?' do
       Puppet::Application.run_status = :stop_requested
-      target = double('target')
-      expect(target).not_to receive(:some_method)
+      target = mock 'target'
+      target.expects(:some_method).never
       Puppet::Application.controlled_run do
         target.some_method
       end
@@ -285,14 +312,14 @@ describe Puppet::Application do
 
     it 'should execute block if :clear?' do
       Puppet::Application.run_status = nil
-      target = double('target')
-      expect(target).to receive(:some_method).once
+      target = mock 'target'
+      target.expects(:some_method).once
       Puppet::Application.controlled_run do
         target.some_method
       end
     end
 
-    describe 'on POSIX systems', :if => Puppet.features.posix? do
+    describe 'on POSIX systems', :if => (Puppet.features.posix? && RUBY_PLATFORM != 'java') do
       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.
 
@@ -325,37 +352,40 @@ describe Puppet::Application do
   end
 
   describe "when parsing command-line options" do
+
     before :each do
-      allow(@app.command_line).to receive(:args).and_return([])
+      @app.command_line.stubs(:args).returns([])
 
-      allow(Puppet.settings).to receive(:optparse_addargs).and_return([])
+      Puppet.settings.stubs(:optparse_addargs).returns([])
     end
 
     it "should pass the banner to the option parser" do
-      option_parser = double("option parser")
-      allow(option_parser).to receive(:on)
-      allow(option_parser).to receive(:parse!)
+      option_parser = stub "option parser"
+      option_parser.stubs(:on)
+      option_parser.stubs(:parse!)
       @app.class.instance_eval do
         banner "banner"
       end
 
-      expect(OptionParser).to receive(:new).with("banner").and_return(option_parser)
+      OptionParser.expects(:new).with("banner").returns(option_parser)
 
       @app.parse_options
     end
 
     it "should ask OptionParser to parse the command-line argument" do
-      allow(@app.command_line).to receive(:args).and_return(%w{ fake args })
-      expect_any_instance_of(OptionParser).to receive(:parse!).with(%w{ fake args })
+      @app.command_line.stubs(:args).returns(%w{ fake args })
+      OptionParser.any_instance.expects(:parse!).with(%w{ fake args })
 
       @app.parse_options
     end
 
     describe "when using --help" do
+
       it "should call exit" do
-        allow(@app).to receive(:puts)
+        @app.stubs(:puts)
         expect { @app.handle_help(nil) }.to exit_with 0
       end
+
     end
 
     describe "when using --version" do
@@ -364,65 +394,59 @@ describe Puppet::Application do
       end
 
       it "should exit after printing the version" do
-        allow(@app).to receive(:puts)
+        @app.stubs(:puts)
         expect { @app.handle_version(nil) }.to exit_with 0
       end
     end
 
     describe "when dealing with an argument not declared directly by the application" do
       it "should pass it to handle_unknown if this method exists" do
-        allow(Puppet.settings).to receive(:optparse_addargs).and_return([["--not-handled", :REQUIRED]])
+        Puppet.settings.stubs(:optparse_addargs).returns([["--not-handled", :REQUIRED]])
 
-        expect(@app).to receive(:handle_unknown).with("--not-handled", "value").and_return(true)
-        allow(@app.command_line).to receive(:args).and_return(["--not-handled", "value"])
+        @app.expects(:handle_unknown).with("--not-handled", "value").returns(true)
+        @app.command_line.stubs(:args).returns(["--not-handled", "value"])
         @app.parse_options
       end
 
       it "should transform boolean option to normal form for Puppet.settings" do
-        expect(@app).to receive(:handle_unknown).with("--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
-        expect(@app).to receive(:handle_unknown).with("--no-option", false)
+        @app.expects(:handle_unknown).with("--no-option", false)
         @app.send(:handlearg, "--[no-]option", false)
       end
+
     end
   end
 
   describe "when calling default setup" do
+
     before :each do
-      allow(@app.options).to receive(:[])
+      @app.options.stubs(:[])
     end
 
     [ :debug, :verbose ].each do |level|
       it "should honor option #{level}" do
-        allow(@app.options).to receive(:[]).with(level).and_return(true)
-        allow(Puppet::Util::Log).to receive(:newdestination)
+        @app.options.stubs(:[]).with(level).returns(true)
+        Puppet::Util::Log.stubs(:newdestination)
         @app.setup
         expect(Puppet::Util::Log.level).to eq(level == :verbose ? :info : :debug)
       end
     end
 
     it "should honor setdest option" do
-      allow(@app.options).to receive(:[]).with(:setdest).and_return(false)
+      @app.options.stubs(:[]).with(:setdest).returns(false)
 
-      expect(Puppet::Util::Log).to receive(:setup_default)
-
-      @app.setup
-    end
-
-    it "sets the log destination if provided via settings" do
-      allow(@app.options).to receive(:[]).and_call_original
-      Puppet[:logdest] = "set_via_config"
-      expect(Puppet::Util::Log).to receive(:newdestination).with("set_via_config")
+      Puppet::Util::Log.expects(:setup_default)
 
       @app.setup
     end
 
     it "does not downgrade the loglevel when --verbose is specified" do
       Puppet[:log_level] = :debug
-      allow(@app.options).to receive(:[]).with(:verbose).and_return(true)
+      @app.options.stubs(:[]).with(:verbose).returns(true)
       @app.setup_logs
 
       expect(Puppet::Util::Log.level).to eq(:debug)
@@ -480,70 +504,74 @@ describe Puppet::Application do
         ROUTES
       end
 
-      expect { @app.configure_indirector_routes }.to raise_error(Psych::SyntaxError, /mapping values are not allowed in this context/)
+      expect { @app.configure_indirector_routes }.to raise_error(Puppet::Error, /mapping values are not allowed/)
     end
   end
 
   describe "when running" do
+
     before :each do
-      allow(@app).to receive(:preinit)
-      allow(@app).to receive(:setup)
-      allow(@app).to receive(:parse_options)
+      @app.stubs(:preinit)
+      @app.stubs(:setup)
+      @app.stubs(:parse_options)
     end
 
     it "should call preinit" do
-      allow(@app).to receive(:run_command)
+      @app.stubs(:run_command)
 
-      expect(@app).to receive(:preinit)
+      @app.expects(:preinit)
 
       @app.run
     end
 
     it "should call parse_options" do
-      allow(@app).to receive(:run_command)
+      @app.stubs(:run_command)
 
-      expect(@app).to receive(:parse_options)
+      @app.expects(:parse_options)
 
       @app.run
     end
 
     it "should call run_command" do
-      expect(@app).to receive(:run_command)
+
+      @app.expects(:run_command)
 
       @app.run
     end
 
+
     it "should call run_command" do
-      expect(@app).to receive(:run_command)
+      @app.expects(:run_command)
 
       @app.run
     end
 
     it "should call main as the default command" do
-      expect(@app).to receive(:main)
+      @app.expects(:main)
 
       @app.run
     end
 
     it "should warn and exit if no command can be called" do
-      expect(Puppet).to receive(:err)
+      Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns no command" do
-      allow(@app).to receive(:get_command).and_return(nil)
-      expect(Puppet).to receive(:err)
+      @app.stubs(:get_command).returns(nil)
+      Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
 
     it "should raise an error if dispatch returns an invalid command" do
-      allow(@app).to receive(:get_command).and_return(:this_function_doesnt_exist)
-      expect(Puppet).to receive(:err)
+      @app.stubs(:get_command).returns(:this_function_doesnt_exist)
+      Puppet.expects(:err)
       expect { @app.run }.to exit_with 1
     end
   end
 
   describe "when metaprogramming" do
+
     describe "when calling option" do
       it "should create a new method named after the option" do
         @app.class.option("--test1","-t") do
@@ -576,8 +604,8 @@ describe Puppet::Application do
         end
 
         it "should declare the option to OptionParser" do
-          allow_any_instance_of(OptionParser).to receive(:on)
-          expect_any_instance_of(OptionParser).to receive(:on).with("--[no-]test3", anything)
+          OptionParser.any_instance.stubs(:on)
+          OptionParser.any_instance.expects(:on).with { |*arg| arg[0] == "--[no-]test3" }
 
           @app.class.option("--[no-]test3","-t") do
           end
@@ -586,10 +614,10 @@ describe Puppet::Application do
         end
 
         it "should pass a block that calls our defined method" do
-          allow_any_instance_of(OptionParser).to receive(:on)
-          allow_any_instance_of(OptionParser).to receive(:on).with('--test4', '-t').and_yield(nil)
+          OptionParser.any_instance.stubs(:on)
+          OptionParser.any_instance.stubs(:on).with('--test4','-t').yields(nil)
 
-          expect(@app).to receive(:send).with(:handle_test4, nil)
+          @app.expects(:send).with(:handle_test4, nil)
 
           @app.class.option("--test4","-t") do
           end
@@ -600,8 +628,8 @@ describe Puppet::Application do
 
       describe "when no block is given" do
         it "should declare the option to OptionParser" do
-          allow_any_instance_of(OptionParser).to receive(:on)
-          expect_any_instance_of(OptionParser).to receive(:on).with("--test4", "-t")
+          OptionParser.any_instance.stubs(:on)
+          OptionParser.any_instance.expects(:on).with("--test4","-t")
 
           @app.class.option("--test4","-t")
 
@@ -609,10 +637,10 @@ describe Puppet::Application do
         end
 
         it "should give to OptionParser a block that adds the value to the options array" do
-          allow_any_instance_of(OptionParser).to receive(:on)
-          allow_any_instance_of(OptionParser).to receive(:on).with("--test4", "-t").and_yield(nil)
+          OptionParser.any_instance.stubs(:on)
+          OptionParser.any_instance.stubs(:on).with("--test4","-t").yields(nil)
 
-          expect(@app.options).to receive(:[]=).with(:test4, nil)
+          @app.options.expects(:[]=).with(:test4,nil)
 
           @app.class.option("--test4","-t")
 
@@ -620,40 +648,30 @@ describe Puppet::Application do
         end
       end
     end
+
   end
 
   describe "#handle_logdest_arg" do
+
     let(:test_arg) { "arg_test_logdest" }
 
     it "should log an exception that is raised" do
       our_exception = Puppet::DevError.new("test exception")
-      expect(Puppet::Util::Log).to receive(:newdestination).with(test_arg).and_raise(our_exception)
-      expect(Puppet).to receive(:log_and_raise).with(our_exception, anything)
+      Puppet::Util::Log.expects(:newdestination).with(test_arg).raises(our_exception)
+      Puppet.expects(:log_exception).with(our_exception)
       @app.handle_logdest_arg(test_arg)
     end
 
-    it "should exit when an exception is raised" do
-      our_exception = Puppet::DevError.new("test exception")
-      expect(Puppet::Util::Log).to receive(:newdestination).with(test_arg).and_raise(our_exception)
-      expect(Puppet).to receive(:log_and_raise).with(our_exception, anything).and_raise(our_exception)
-      expect { @app.handle_logdest_arg(test_arg) }.to raise_error(Puppet::DevError)
-    end
-
     it "should set the new log destination" do
-      expect(Puppet::Util::Log).to receive(:newdestination).with(test_arg)
+      Puppet::Util::Log.expects(:newdestination).with(test_arg)
       @app.handle_logdest_arg(test_arg)
     end
 
     it "should set the flag that a destination is set in the options hash" do
-      allow(Puppet::Util::Log).to receive(:newdestination).with(test_arg)
+      Puppet::Util::Log.stubs(:newdestination).with(test_arg)
       @app.handle_logdest_arg(test_arg)
       expect(@app.options[:setdest]).to be_truthy
     end
-
-    it "does not set the log destination if arg is nil" do
-      expect(Puppet::Util::Log).not_to receive(:newdestination)
-
-      @app.handle_logdest_arg(nil)
-    end
   end
+
 end