puppet 2.6.18 → 2.7.1

data/spec/unit/application/apply_spec.rb

@@ -1,17 +1,14 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
+#!/usr/bin/env rspec
+require 'spec_helper'
 
 require 'puppet/application/apply'
 require 'puppet/file_bucket/dipper'
 require 'puppet/configurer'
-require 'fileutils'
 
 describe Puppet::Application::Apply do
   before :each do
     @apply = Puppet::Application[:apply]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
   end
 
   [:debug,:loadclasses,:verbose,:use_nodes,:detailed_exitcodes].each do |option|
@@ -53,11 +50,10 @@ describe Puppet::Application::Apply do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
-      Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
       STDIN.stubs(:read)
-      Puppet::Transaction::Report.stubs(:cache_class=)
+      Puppet::Transaction::Report.indirection.stubs(:cache_class=)
 
       @apply.options.stubs(:[]).with(any_parameters)
     end
@@ -86,37 +82,29 @@ describe Puppet::Application::Apply do
 
     it "should set log level to debug if --debug was passed" do
       @apply.options.stubs(:[]).with(:debug).returns(true)
-
-      Puppet::Log.expects(:level=).with(:debug)
-
       @apply.setup
+      Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
       @apply.options.stubs(:[]).with(:verbose).returns(true)
-
-      Puppet::Log.expects(:level=).with(:info)
-
       @apply.setup
+      Puppet::Log.level.should == :info
     end
 
     it "should print puppet config if asked to in Puppet config" do
-      @apply.stubs(:exit)
-      Puppet.settings.stubs(:print_configs?).returns(true)
-
-      Puppet.settings.expects(:print_configs)
-
-      @apply.setup
+      Puppet.settings.stubs(:print_configs?).returns  true
+      Puppet.settings.expects(:print_configs).returns true
+      expect { @apply.setup }.to exit_with 0
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
-
-      lambda { @apply.setup }.should raise_error(SystemExit)
+      expect { @apply.setup }.to exit_with 1
     end
 
     it "should tell the report handler to cache locally as yaml" do
-      Puppet::Transaction::Report.expects(:cache_class=).with(:yaml)
+      Puppet::Transaction::Report.indirection.expects(:cache_class=).with(:yaml)
 
       @apply.setup
     end
@@ -124,14 +112,6 @@ describe Puppet::Application::Apply do
 
   describe "when executing" do
 
-    it "should dispatch to parseonly if parseonly is set" do
-      @apply.stubs(:options).returns({})
-      Puppet.stubs(:[]).with(:parseonly).returns(true)
-
-      @apply.expects(:parseonly)
-      @apply.run_command
-    end
-
     it "should dispatch to 'apply' if it was called with 'apply'" do
       @apply.options[:catalog] = "foo"
 
@@ -139,75 +119,36 @@ describe Puppet::Application::Apply do
       @apply.run_command
     end
 
-    it "should dispatch to main if parseonly is not set" do
+    it "should dispatch to main otherwise" do
       @apply.stubs(:options).returns({})
-      Puppet.stubs(:[]).with(:parseonly).returns(false)
 
       @apply.expects(:main)
       @apply.run_command
     end
 
-    describe "the parseonly command" do
-      before :each do
-        Puppet.stubs(:[]).with(:environment)
-        Puppet.stubs(:[]).with(:manifest).returns("site.pp")
-        Puppet.stubs(:err)
-        @apply.stubs(:exit)
-        @apply.options.stubs(:[]).with(:code).returns "some code"
-        @collection = stub_everything
-        Puppet::Resource::TypeCollection.stubs(:new).returns(@collection)
-      end
-
-      it "should use a Puppet Resource Type Collection to parse the file" do
-        @collection.expects(:perform_initial_import)
-        @apply.parseonly
-      end
-
-      it "should exit with exit code 0 if no error" do
-        @apply.expects(:exit).with(0)
-        @apply.parseonly
-      end
-
-      it "should exit with exit code 1 if error" do
-        @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
-        @apply.expects(:exit).with(1)
-        @apply.parseonly
-      end
-
-      it "should exit with exit code 1 if error, even if --noop is set" do
-        Puppet[:noop] = true
-        @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
-        @apply.expects(:exit).with(1)
-        @apply.parseonly
-      end
-    end
-
     describe "the main command" do
-      include PuppetSpec::Files
-
       before :each do
-        Puppet[:prerun_command] = ''
-        Puppet[:postrun_command] = ''
+        Puppet.stubs(:[])
+        Puppet.settings.stubs(:use)
+        Puppet.stubs(:[]).with(:prerun_command).returns ""
+        Puppet.stubs(:[]).with(:postrun_command).returns ""
+        Puppet.stubs(:[]).with(:trace).returns(true)
 
-        Puppet::Node::Facts.terminus_class = :memory
-        Puppet::Node.terminus_class = :memory
+        @apply.options.stubs(:[])
 
-        @facts = Puppet::Node::Facts.new(Puppet[:node_name_value])
-        @facts.save
+        @facts = stub_everything 'facts'
+        Puppet::Node::Facts.indirection.stubs(:find).returns(@facts)
 
-        @node = Puppet::Node.new(Puppet[:node_name_value])
-        @node.save
+        @node = stub_everything 'node'
+        Puppet::Node.indirection.stubs(:find).returns(@node)
 
-        @catalog = Puppet::Resource::Catalog.new
+        @catalog = stub_everything 'catalog'
         @catalog.stubs(:to_ral).returns(@catalog)
-
-        Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
+        Puppet::Resource::Catalog.indirection.stubs(:find).returns(@catalog)
 
         STDIN.stubs(:read)
 
-        @apply.stubs(:exit)
-
-        @transaction = Puppet::Transaction.new(@catalog)
+        @transaction = stub_everything 'transaction'
         @catalog.stubs(:apply).returns(@transaction)
 
         Puppet::Util::Storage.stubs(:load)
@@ -215,10 +156,10 @@ describe Puppet::Application::Apply do
       end
 
       it "should set the code to run from --code" do
-        @apply.options[:code] = "code to run"
+        @apply.options.stubs(:[]).with(:code).returns("code to run")
         Puppet.expects(:[]=).with(:code,"code to run")
 
-        @apply.main
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should set the code to run from STDIN if no arguments" do
@@ -227,158 +168,153 @@ describe Puppet::Application::Apply do
 
         Puppet.expects(:[]=).with(:code,"code to run")
 
-        @apply.main
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should set the manifest if a file is passed on command line and the file exists" do
-        manifest = tmpfile('site.pp')
-        FileUtils.touch(manifest)
-        @apply.command_line.stubs(:args).returns([manifest])
+        File.stubs(:exist?).with('site.pp').returns true
+        @apply.command_line.stubs(:args).returns(['site.pp'])
 
-        Puppet.expects(:[]=).with(:manifest,manifest)
+        Puppet.expects(:[]=).with(:manifest,"site.pp")
 
-        @apply.main
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should raise an error if a file is passed on command line and the file does not exist" do
-        noexist = tmpfile('noexist.pp')
-        @apply.command_line.stubs(:args).returns([noexist])
-        lambda { @apply.main }.should raise_error(RuntimeError, "Could not find file #{noexist}")
+        File.stubs(:exist?).with('noexist.pp').returns false
+        @apply.command_line.stubs(:args).returns(['noexist.pp'])
+        lambda { @apply.main }.should raise_error(RuntimeError, 'Could not find file noexist.pp')
       end
 
       it "should set the manifest to the first file and warn other files will be skipped" do
-        manifest = tmpfile('starwarsIV')
-        FileUtils.touch(manifest)
-
-        @apply.command_line.stubs(:args).returns([manifest, 'starwarsI', 'starwarsII'])
+        File.stubs(:exist?).with('starwarsIV').returns true
+        File.expects(:exist?).with('starwarsI').never
+        @apply.command_line.stubs(:args).returns(['starwarsIV', 'starwarsI', 'starwarsII'])
 
-        Puppet.expects(:[]=).with(:manifest,manifest)
+        Puppet.expects(:[]=).with(:manifest,"starwarsIV")
         Puppet.expects(:warning).with('Only one file can be applied per run.  Skipping starwarsI, starwarsII')
 
-        @apply.main
+        expect { @apply.main }.to exit_with 0
       end
 
-      it "should set the facts name based on the node_name_fact" do
-        @facts = Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name')
-        @facts.save
-        Puppet::Node.new('other_node_name').save
-        Puppet[:node_name_fact] = 'my_name_fact'
+      it "should collect the node facts" do
+        Puppet::Node::Facts.indirection.expects(:find).returns(@facts)
 
-        @apply.main
-
-        @facts.name.should == 'other_node_name'
+        expect { @apply.main }.to exit_with 0
       end
 
-      it "should set the node_name_value based on the node_name_fact" do
-        Puppet::Node::Facts.new(Puppet[:node_name_value], 'my_name_fact' => 'other_node_name').save
-        Puppet::Node.new('other_node_name').save
-        Puppet[:node_name_fact] = 'my_name_fact'
-
-        @apply.main
+      it "should raise an error if we can't find the node" do
+        Puppet::Node::Facts.indirection.expects(:find).returns(nil)
 
-        Puppet[:node_name_value].should == 'other_node_name'
+        lambda { @apply.main }.should raise_error
       end
 
-      it "should raise an error if we can't find the facts" do
-        Puppet::Node::Facts.expects(:find).returns(nil)
+      it "should look for the node" do
+        Puppet::Node.indirection.expects(:find).returns(@node)
 
-        lambda { @apply.main }.should raise_error
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should raise an error if we can't find the node" do
-        Puppet::Node.expects(:find).returns(nil)
+        Puppet::Node.indirection.expects(:find).returns(nil)
 
         lambda { @apply.main }.should raise_error
       end
 
       it "should merge in our node the loaded facts" do
-        @facts.values = {'key' => 'value'}
+        @facts.stubs(:values).returns("values")
 
-        @apply.main
+        @node.expects(:merge).with("values")
 
-        @node.parameters['key'].should == 'value'
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should load custom classes if loadclasses" do
-        @apply.options[:loadclasses] = true
-        classfile = tmpfile('classfile')
-        File.open(classfile, 'w') { |c| c.puts 'class' }
-        Puppet[:classfile] = classfile
+        @apply.options.stubs(:[]).with(:loadclasses).returns(true)
+        Puppet.stubs(:[]).with(:classfile).returns("/etc/puppet/classes.txt")
+        FileTest.stubs(:exists?).with("/etc/puppet/classes.txt").returns(true)
+        FileTest.stubs(:readable?).with("/etc/puppet/classes.txt").returns(true)
+        File.stubs(:read).with("/etc/puppet/classes.txt").returns("class")
 
-        @node.expects(:classes=).with(['class'])
+        @node.expects(:classes=)
 
-        @apply.main
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should compile the catalog" do
-        Puppet::Resource::Catalog.expects(:find).returns(@catalog)
+        Puppet::Resource::Catalog.indirection.expects(:find).returns(@catalog)
 
-        @apply.main
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should transform the catalog to ral" do
 
         @catalog.expects(:to_ral).returns(@catalog)
 
-        @apply.main
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should finalize the catalog" do
         @catalog.expects(:finalize)
 
-        @apply.main
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should call the prerun and postrun commands on a Configurer instance" do
         Puppet::Configurer.any_instance.expects(:execute_prerun_command)
         Puppet::Configurer.any_instance.expects(:execute_postrun_command)
 
-        @apply.main
+        expect { @apply.main }.to exit_with 0
       end
 
       it "should apply the catalog" do
         @catalog.expects(:apply).returns(stub_everything('transaction'))
 
-        @apply.main
+        expect { @apply.main }.to exit_with 0
       end
 
-      describe "with detailed_exitcodes" do
-        before :each do
-          @apply.options[:detailed_exitcodes] = true
-        end
+      it "should save the last run summary" do
+        Puppet.stubs(:[]).with(:noop).returns(false)
+        report = Puppet::Transaction::Report.new("apply")
+        Puppet::Transaction::Report.stubs(:new).returns(report)
 
+        Puppet::Configurer.any_instance.expects(:save_last_run_summary).with(report)
+        expect { @apply.main }.to exit_with 0
+      end
+
+      describe "with detailed_exitcodes" do
         it "should exit with report's computed exit status" do
-          Puppet[:noop] = false
+          Puppet.stubs(:[]).with(:noop).returns(false)
+          @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
-          @apply.expects(:exit).with(666)
 
-          @apply.main
+          expect { @apply.main }.to exit_with 666
         end
 
         it "should exit with report's computed exit status, even if --noop is set" do
-          Puppet[:noop] = true
+          Puppet.stubs(:[]).with(:noop).returns(true)
+          @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
-          @apply.expects(:exit).with(666)
 
-          @apply.main
+          expect { @apply.main }.to exit_with 666
         end
 
         it "should always exit with 0 if option is disabled" do
-          Puppet[:noop] = false
+          Puppet.stubs(:[]).with(:noop).returns(false)
+          @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
-          @apply.expects(:exit).with(0)
 
-          @apply.main
+          expect { @apply.main }.to exit_with 0
         end
 
         it "should always exit with 0 if --noop" do
-          Puppet[:noop] = true
+          Puppet.stubs(:[]).with(:noop).returns(true)
+          @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
-          @apply.expects(:exit).with(0)
 
-          @apply.main
+          expect { @apply.main }.to exit_with 0
         end
       end
     end

data/spec/unit/application/cert_spec.rb

@@ -1,14 +1,11 @@
-#!/usr/bin/env ruby
-
-require File.dirname(__FILE__) + '/../../spec_helper'
-
+#!/usr/bin/env rspec
+require 'spec_helper'
 require 'puppet/application/cert'
 
-describe Puppet::Application::Cert do
+describe Puppet::Application::Cert, :'fails_on_ruby_1.9.2' => true do
   before :each do
     @cert_app = Puppet::Application[:cert]
     Puppet::Util::Log.stubs(:newdestination)
-    Puppet::Util::Log.stubs(:level=)
   end
 
   it "should operate in master run_mode" do
@@ -30,22 +27,17 @@ describe Puppet::Application::Cert do
   end
 
   it "should set log level to info with the --verbose option" do
-
-    Puppet::Log.expects(:level=).with(:info)
-
     @cert_app.handle_verbose(0)
+    Puppet::Log.level.should == :info
   end
 
   it "should set log level to debug with the --debug option" do
-
-    Puppet::Log.expects(:level=).with(:debug)
-
     @cert_app.handle_debug(0)
+    Puppet::Log.level.should == :debug
   end
 
   it "should set the fingerprint digest with the --digest option" do
     @cert_app.handle_digest(:digest)
-
     @cert_app.digest.should == :digest
   end
 
@@ -87,18 +79,14 @@ describe Puppet::Application::Cert do
     end
 
     it "should print puppet config if asked to in Puppet config" do
-      @cert_app.stubs(:exit)
       Puppet.settings.stubs(:print_configs?).returns(true)
-
-      Puppet.settings.expects(:print_configs)
-
-      @cert_app.setup
+      Puppet.settings.expects(:print_configs).returns true
+      expect { @cert_app.setup }.to exit_with 0
     end
 
     it "should exit after printing puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
-
-      lambda { @cert_app.setup }.should raise_error(SystemExit)
+      expect { @cert_app.setup }.to exit_with 1
     end
 
     it "should set the CA location to 'only'" do
@@ -189,16 +177,6 @@ describe Puppet::Application::Cert do
       @cert_app.ca = @ca
     end
 
-    it "should not fail when no command is given" do
-      # Make the help method silent for testing; this is a bit nasty, but we
-      # can't identify a cleaner method.  Help welcome. --daniel 2011-02-22
-      Puppet.features.stubs(:usage?).returns(false)
-      @cert_app.stubs(:puts)
-
-      @cert_app.command_line.stubs(:args).returns([])
-      expect { @cert_app.parse_options }.should raise_error SystemExit
-    end
-
     %w{list revoke generate sign print verify fingerprint}.each do |cmd|
       short = cmd[0,1]
       [cmd, "--#{cmd}", "-#{short}"].each do |option|