puppet 3.8.7 → 4.0.0.rc1

data/spec/unit/application/doc_spec.rb

@@ -14,45 +14,45 @@ describe Puppet::Application::Doc do
   end
 
   it "should declare an other command" do
-    @doc.should respond_to(:other)
+    expect(@doc).to respond_to(:other)
   end
 
   it "should declare a rdoc command" do
-    @doc.should respond_to(:rdoc)
+    expect(@doc).to respond_to(:rdoc)
   end
 
   it "should declare a fallback for unknown options" do
-    @doc.should respond_to(:handle_unknown)
+    expect(@doc).to respond_to(:handle_unknown)
   end
 
   it "should declare a preinit block" do
-    @doc.should respond_to(:preinit)
+    expect(@doc).to respond_to(:preinit)
   end
 
   describe "in preinit" do
     it "should set references to []" do
       @doc.preinit
 
-      @doc.options[:references].should == []
+      expect(@doc.options[:references]).to eq([])
     end
 
     it "should init mode to text" do
       @doc.preinit
 
-      @doc.options[:mode].should == :text
+      expect(@doc.options[:mode]).to eq(:text)
     end
 
     it "should init format to to_markdown" do
       @doc.preinit
 
-      @doc.options[:format].should == :to_markdown
+      expect(@doc.options[:format]).to eq(:to_markdown)
     end
   end
 
   describe "when handling options" do
     [:all, :outputdir, :verbose, :debug, :charset].each do |option|
       it "should declare handle_#{option} method" do
-        @doc.should respond_to("handle_#{option}".to_sym)
+        expect(@doc).to respond_to("handle_#{option}".to_sym)
       end
 
       it "should store argument value when calling handle_#{option}" do
@@ -65,7 +65,7 @@ describe Puppet::Application::Doc do
       Puppet::Util::Reference.stubs(:method_defined?).with('to_format').returns(true)
 
       @doc.handle_format('format')
-      @doc.options[:format].should == 'to_format'
+      expect(@doc.options[:format]).to eq('to_format')
     end
 
     it "should raise an error if the format is not valid" do
@@ -77,14 +77,14 @@ describe Puppet::Application::Doc do
       Puppet::Util::Reference.stubs(:modes).returns(stub('mode', :include? => true))
 
       @doc.handle_mode('mode')
-      @doc.options[:mode].should == :mode
+      expect(@doc.options[:mode]).to eq(:mode)
     end
 
     it "should store the mode if :rdoc" do
       Puppet::Util::Reference.modes.stubs(:include?).with('rdoc').returns(false)
 
       @doc.handle_mode('rdoc')
-      @doc.options[:mode].should == :rdoc
+      expect(@doc.options[:mode]).to eq(:rdoc)
     end
 
     it "should raise an error if the mode is not valid" do
@@ -108,7 +108,7 @@ describe Puppet::Application::Doc do
 
       @doc.handle_reference('ref2')
 
-      @doc.options[:references].should == [:ref1,:ref2]
+      expect(@doc.options[:references]).to eq([:ref1,:ref2])
     end
   end
 
@@ -124,7 +124,7 @@ describe Puppet::Application::Doc do
       @doc.stubs(:setup_rdoc)
 
       @doc.setup
-      @doc.options[:mode].should == :rdoc
+      expect(@doc.options[:mode]).to eq(:rdoc)
     end
 
     it "should call setup_rdoc in rdoc mode" do
@@ -155,7 +155,7 @@ describe Puppet::Application::Doc do
 
         it "should set log level to debug" do
           @doc.setup
-          Puppet::Util::Log.level.should == :debug
+          expect(Puppet::Util::Log.level).to eq(:debug)
         end
 
         it "should set log destination to console" do
@@ -171,7 +171,7 @@ describe Puppet::Application::Doc do
 
         it "should set log level to info" do
           @doc.setup
-          Puppet::Util::Log.level.should == :info
+          expect(Puppet::Util::Log.level).to eq(:info)
         end
 
         it "should set log destination to console" do
@@ -188,7 +188,7 @@ describe Puppet::Application::Doc do
 
         it "should set log level to warning" do
           @doc.setup
-          Puppet::Util::Log.level.should == :warning
+          expect(Puppet::Util::Log.level).to eq(:warning)
         end
 
         it "should set log destination to console" do
@@ -208,12 +208,12 @@ describe Puppet::Application::Doc do
         Puppet::Util::Reference.stubs(:references).returns([:static,:dynamic])
 
         @doc.setup_reference
-        @doc.options[:references].should == [:static]
+        expect(@doc.options[:references]).to eq([:static])
       end
 
       it "should default to :type if no references" do
         @doc.setup_reference
-        @doc.options[:references].should == [:type]
+        expect(@doc.options[:references]).to eq([:type])
       end
     end
 
@@ -225,16 +225,7 @@ describe Puppet::Application::Doc do
 
           @doc.setup_rdoc
 
-          @doc.unknown_args[0][:arg].should == File.expand_path('path')
-        end
-
-        it "should expand --manifestdir if any" do
-          @doc.unknown_args = [ { :opt => "--manifestdir", :arg => "path" } ]
-          Puppet.settings.stubs(:handlearg)
-
-          @doc.setup_rdoc
-
-          @doc.unknown_args[0][:arg].should == File.expand_path('path')
+          expect(@doc.unknown_args[0][:arg]).to eq(File.expand_path('path'))
         end
 
         it "should give them to Puppet.settings" do
@@ -246,7 +237,7 @@ describe Puppet::Application::Doc do
       end
 
       it "should operate in master run_mode" do
-        @doc.class.run_mode.name.should == :master
+        expect(@doc.class.run_mode.name).to eq(:master)
 
         @doc.setup_rdoc
       end
@@ -267,7 +258,7 @@ describe Puppet::Application::Doc do
         Puppet.stubs(:info)
         Puppet[:trace] = false
         Puppet[:modulepath] = modules
-        Puppet[:manifestdir] = manifests
+        Puppet[:manifest] = manifests
         @doc.options[:all] = false
         @doc.options[:outputdir] = 'doc'
         @doc.options[:charset] = nil
@@ -314,7 +305,7 @@ describe Puppet::Application::Doc do
         expect { @doc.rdoc }.to exit_with(0)
       end
 
-      it "should get modulepath and manifestdir values from the environment" do
+      it "should get modulepath and manifest values from the environment" do
         FileUtils.mkdir_p(modules)
         FileUtils.mkdir_p(modules2)
         env = Puppet::Node::Environment.create(Puppet[:environment].to_sym,

data/spec/unit/application/face_base_spec.rb

@@ -23,7 +23,7 @@ describe Puppet::Application::FaceBase do
       option = mock('ca option', :optparse_args => ["--ca"])
       Puppet.settings.expects(:each).yields(:ca, option)
 
-      app.find_global_settings_argument("--ca-location").should be_nil
+      expect(app.find_global_settings_argument("--ca-location")).to be_nil
     end
   end
 
@@ -47,21 +47,21 @@ describe Puppet::Application::FaceBase do
       end
 
       it "should set the face based on the type" do
-        app.face.name.should == :basetest
+        expect(app.face.name).to eq(:basetest)
       end
 
       it "should find the action" do
-        app.action.should be
-        app.action.name.should == :foo
+        expect(app.action).to be
+        expect(app.action.name).to eq(:foo)
       end
     end
 
     it "should stop if the first thing found is not an action" do
       app.command_line.stubs(:args).returns %w{banana count_args}
 
-      expect { app.run }.to exit_with 1
+      expect { app.run }.to exit_with(1)
 
-      @logs.map(&:message).should == ["'basetest' has no 'banana' action.  See `puppet help basetest`."]
+      expect(@logs.map(&:message)).to eq(["'basetest' has no 'banana' action.  See `puppet help basetest`."])
     end
 
     it "should use the default action if not given any arguments" do
@@ -70,8 +70,8 @@ describe Puppet::Application::FaceBase do
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
-      app.action.should == action
-      app.arguments.should == [ { } ]
+      expect(app.action).to eq(action)
+      expect(app.arguments).to eq([ { } ])
     end
 
     it "should use the default action if not given a valid one" do
@@ -80,16 +80,16 @@ describe Puppet::Application::FaceBase do
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(action)
       app.stubs(:main)
       app.run
-      app.action.should == action
-      app.arguments.should == [ 'bar', { } ]
+      expect(app.action).to eq(action)
+      expect(app.arguments).to eq([ 'bar', { } ])
     end
 
     it "should have no action if not given a valid one and there is no default action" do
       app.command_line.stubs(:args).returns %w{bar}
       Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
       app.stubs(:main)
-      expect { app.run }.to exit_with 1
-      @logs.first.message.should =~ /has no 'bar' action./
+      expect { app.run }.to exit_with(1)
+      expect(@logs.first.message).to match(/has no 'bar' action./)
     end
 
     [%w{something_I_cannot_do},
@@ -98,8 +98,8 @@ describe Puppet::Application::FaceBase do
         app.command_line.stubs(:args).returns input
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
         app.stubs(:main)
-        expect { app.run }.to exit_with 1
-        @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
+        expect { app.run }.to exit_with(1)
+        expect(@logs.first.message).to match(/has no 'something_I_cannot_do' action/)
       end
     end
 
@@ -109,71 +109,87 @@ describe Puppet::Application::FaceBase do
         app.command_line.stubs(:args).returns input
         Puppet::Face[:basetest, '0.0.1'].expects(:get_default_action).returns(nil)
         app.stubs(:main)
-        expect { app.run }.to exit_with 1
-        @logs.first.message.should =~ /has no 'something_I_cannot_do' action/
+        expect { app.run }.to exit_with(1)
+        expect(@logs.first.message).to match(/has no 'something_I_cannot_do' action/)
       end
     end
 
     it "should report a sensible error when options with = fail" do
       app.command_line.stubs(:args).returns %w{--action=bar foo}
       expect { app.preinit; app.parse_options }.
-        to raise_error OptionParser::InvalidOption, /invalid option: --action/
+        to raise_error(OptionParser::InvalidOption, /invalid option: --action/)
     end
 
     it "should fail if an action option is before the action" do
       app.command_line.stubs(:args).returns %w{--action foo}
       expect { app.preinit; app.parse_options }.
-        to raise_error OptionParser::InvalidOption, /invalid option: --action/
+        to raise_error(OptionParser::InvalidOption, /invalid option: --action/)
     end
 
     it "should fail if an unknown option is before the action" do
       app.command_line.stubs(:args).returns %w{--bar foo}
       expect { app.preinit; app.parse_options }.
-        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+        to raise_error(OptionParser::InvalidOption, /invalid option: --bar/)
     end
 
     it "should fail if an unknown option is after the action" do
       app.command_line.stubs(:args).returns %w{foo --bar}
       expect { app.preinit; app.parse_options }.
-        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+        to raise_error(OptionParser::InvalidOption, /invalid option: --bar/)
     end
 
     it "should accept --bar as an argument to a mandatory option after action" do
       app.command_line.stubs(:args).returns %w{foo --mandatory --bar}
       app.preinit
       app.parse_options
-      app.action.name.should == :foo
-      app.options.should == { :mandatory => "--bar" }
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({ :mandatory => "--bar" })
     end
 
     it "should accept --bar as an argument to a mandatory option before action" do
       app.command_line.stubs(:args).returns %w{--mandatory --bar foo}
       app.preinit
       app.parse_options
-      app.action.name.should == :foo
-      app.options.should == { :mandatory => "--bar" }
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({ :mandatory => "--bar" })
     end
 
     it "should not skip when --foo=bar is given" do
       app.command_line.stubs(:args).returns %w{--mandatory=bar --bar foo}
       expect { app.preinit; app.parse_options }.
-        to raise_error OptionParser::InvalidOption, /invalid option: --bar/
+        to raise_error(OptionParser::InvalidOption, /invalid option: --bar/)
     end
 
     it "does not skip when a puppet global setting is given as one item" do
       app.command_line.stubs(:args).returns %w{--confdir=/tmp/puppet foo}
       app.preinit
       app.parse_options
-      app.action.name.should == :foo
-      app.options.should == {}
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
     end
 
     it "does not skip when a puppet global setting is given as two items" do
       app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo}
       app.preinit
       app.parse_options
-      app.action.name.should == :foo
-      app.options.should == {}
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
+    end
+
+    it "should not add :debug to the application-level options" do
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo --debug}
+      app.preinit
+      app.parse_options
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
+    end
+
+    it "should not add :verbose to the application-level options" do
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo --verbose}
+      app.preinit
+      app.parse_options
+      expect(app.action.name).to eq(:foo)
+      expect(app.options).to eq({})
     end
 
     { "boolean options before" => %w{--trace foo},
@@ -184,7 +200,7 @@ describe Puppet::Application::FaceBase do
         Puppet.settings.initialize_global_settings(args)
         app.preinit
         app.parse_options
-        Puppet[:trace].should be_true
+        expect(Puppet[:trace]).to be_truthy
       end
     end
 
@@ -196,7 +212,7 @@ describe Puppet::Application::FaceBase do
         Puppet.settings.initialize_global_settings(args)
         app.preinit
         app.parse_options
-        Puppet[:syslogfacility].should == "user1"
+        expect(Puppet[:syslogfacility]).to eq("user1")
       end
     end
 
@@ -204,7 +220,7 @@ describe Puppet::Application::FaceBase do
       app.command_line.stubs(:args).returns %w{--verbose return_true}
       app.preinit
       app.parse_options
-      app.face.name.should == :basetest
+      expect(app.face.name).to eq(:basetest)
     end
   end
 
@@ -214,7 +230,7 @@ describe Puppet::Application::FaceBase do
       app.preinit
       app.parse_options
       app.setup
-      app.arguments.should == [{ :mandatory => "--bar" }]
+      expect(app.arguments).to eq([{ :mandatory => "--bar" }])
     end
 
     it "should pass positional arguments" do
@@ -223,7 +239,7 @@ describe Puppet::Application::FaceBase do
       app.preinit
       app.parse_options
       app.setup
-      app.arguments.should == ['bar', 'baz', 'quux', { :mandatory => "--bar" }]
+      expect(app.arguments).to eq(['bar', 'baz', 'quux', { :mandatory => "--bar" }])
     end
   end
 
@@ -238,18 +254,18 @@ describe Puppet::Application::FaceBase do
 
     it "should send the specified verb and name to the face" do
       app.face.expects(:foo).with(*app.arguments)
-      expect { app.main }.to exit_with 0
+      expect { app.main }.to exit_with(0)
     end
 
     it "should lookup help when it cannot do anything else" do
       app.action = nil
       Puppet::Face[:help, :current].expects(:help).with(:basetest)
-      expect { app.main }.to exit_with 1
+      expect { app.main }.to exit_with(1)
     end
 
     it "should use its render method to render any result" do
       app.expects(:render).with(app.arguments.length + 1, ["myname", "myarg"])
-      expect { app.main }.to exit_with 0
+      expect { app.main }.to exit_with(0)
     end
   end
 
@@ -264,27 +280,27 @@ describe Puppet::Application::FaceBase do
 
     it "should exit 0 when the action returns true" do
       app.action    = app.face.get_action :return_true
-      expect { app.main }.to exit_with 0
+      expect { app.main }.to exit_with(0)
     end
 
     it "should exit 0 when the action returns false" do
       app.action = app.face.get_action :return_false
-      expect { app.main }.to exit_with 0
+      expect { app.main }.to exit_with(0)
     end
 
     it "should exit 0 when the action returns nil" do
       app.action = app.face.get_action :return_nil
-      expect { app.main }.to exit_with 0
+      expect { app.main }.to exit_with(0)
     end
 
     it "should exit non-0 when the action raises" do
       app.action = app.face.get_action :return_raise
-      expect { app.main }.not_to exit_with 0
+      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
+      expect { app.main }.to exit_with(5)
     end
   end
 
@@ -299,19 +315,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
+          expect(app.render(input, {})).to eq(input)
         end
       end
 
       [[1, 2], ["one"], [{ 1 => 1 }]].each do |input|
         it "should render Array as one item per line" do
-          app.render(input, {}).should == input.collect { |item| item.to_s + "\n" }.join('')
+          expect(app.render(input, {})).to eq(input.collect { |item| item.to_s + "\n" }.join(''))
         end
       end
 
-      it "should render a non-trivially-keyed Hash with using JSON" do
+      it "should render a non-trivially-keyed Hash with using pretty printed PSON" do
         hash = { [1,2] => 3, [2,3] => 5, [3,4] => 7 }
-        app.render(hash, {}).should == hash.to_pson.chomp
+        expect(app.render(hash, {})).to eq(PSON.pretty_generate(hash).chomp)
       end
 
       it "should render a {String,Numeric}-keyed Hash into a table" do
@@ -321,7 +337,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
+        expect(app.render(hash, {})).to eq <<EOT
 5      5
 6.0    6
 four   #{object.to_pson.chomp}
@@ -337,7 +353,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
+        expect(app.render(hash, {})).to eq <<EOT
 number  {"1"=>"1111111111111111111111111111111111111111",
          "2"=>"2222222222222222222222222222222222222222",
          "3"=>"3333333333333333333333333333333333333333"}
@@ -355,7 +371,7 @@ EOT
 
         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!"
+          expect(app.render("bi-polar?", {})).to eq("bi-winning!")
         end
 
         it "should invoke the action rendering hook with args and options while rendering" do
@@ -365,16 +381,16 @@ EOT
             :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"
+          expect(app.render("bi-polar?", ['bob', {:altername => 'sue'}])).to eq("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.should =~ /"one":\s*1\b/
-        json.should =~ /"two":\s*2\b/
-        PSON.parse(json).should == { "one" => 1, "two" => 2 }
+        expect(json).to match(/"one":\s*1\b/)
+        expect(json).to match(/"two":\s*2\b/)
+        expect(PSON.parse(json)).to eq({ "one" => 1, "two" => 2 })
       end
     end
 
@@ -386,23 +402,36 @@ EOT
 
       Puppet.expects(:err).with("Could not parse application options: I don't know how to render 'interpretive-dance'")
 
-      expect { app.run }.to exit_with 1
-
+      expect { app.run }.to exit_with(1)
     end
 
     it "should work if asked to render a NetworkHandler format" do
-      app.command_line.stubs(:args).returns %w{count_args a b c --render-as yaml}
+      app.command_line.stubs(:args).returns %w{count_args a b c --render-as pson}
       expect {
-        expect { app.run }.to exit_with 0
-      }.to have_printed(/--- 3/)
+        expect { app.run }.to exit_with(0)
+      }.to have_printed(/3/)
     end
 
     it "should invoke when_rendering hook 's' when asked to render-as 's'" do
       app.command_line.stubs(:args).returns %w{with_s_rendering_hook --render-as s}
       app.action = app.face.get_action(:with_s_rendering_hook)
       expect {
-        expect { app.run }.to exit_with 0
+        expect { app.run }.to exit_with(0)
       }.to have_printed(/you invoked the 's' rendering hook/)
     end
   end
+
+  describe "#help" do
+    it "should generate help for --help" do
+      app.command_line.stubs(:args).returns %w{--help}
+      Puppet::Face[:help, :current].expects(:help)
+      expect { app.run }.to exit_with(0)
+    end
+
+    it "should generate help for -h" do
+      app.command_line.stubs(:args).returns %w{-h}
+      Puppet::Face[:help, :current].expects(:help)
+      expect { app.run }.to exit_with(0)
+    end
+  end
 end