puppet 2.6.8 → 2.6.9

data/lib/puppet/parser/resource.rb

@@ -62,13 +62,30 @@ class Puppet::Parser::Resource < Puppet::Resource
     scope.environment
   end
 
+  # Process the  stage metaparameter for a class.   A containment edge
+  # is drawn from  the class to the stage.   The stage for containment
+  # defaults to main, if none is specified.
+  def add_edge_to_stage
+    return unless self.type.to_s.downcase == "class"
+
+    unless stage = catalog.resource(:stage, self[:stage] || (scope && scope.resource && scope.resource[:stage]) || :main)
+      raise ArgumentError, "Could not find stage #{self[:stage] || :main} specified by #{self}"
+    end
+
+    self[:stage] ||= stage.title unless stage.title == :main
+    catalog.add_edge(stage, self)
+  end
+
   # Retrieve the associated definition and evaluate it.
   def evaluate
     return if evaluated?
     @evaluated = true
     if klass = resource_type and ! builtin_type?
       finish
-      return klass.evaluate_code(self)
+      evaluated_code = klass.evaluate_code(self)
+      add_edge_to_stage
+
+      return evaluated_code
     elsif builtin?
       devfail "Cannot evaluate a builtin type (#{type})"
     else

data/lib/puppet/parser/scope.rb

@@ -101,7 +101,7 @@ class Puppet::Parser::Scope
 
   # Remove this when rebasing
   def environment
-    compiler.environment
+    compiler ? compiler.environment : nil
   end
 
   # Are we the top scope?
@@ -513,6 +513,6 @@ class Puppet::Parser::Scope
 
   def extend_with_functions_module
     extend Puppet::Parser::Functions.environment_module(Puppet::Node::Environment.root)
-    extend Puppet::Parser::Functions.environment_module(compiler ? environment : nil)
+    extend Puppet::Parser::Functions.environment_module(environment)
   end
 end

data/lib/puppet/provider/mount/parsed.rb

@@ -18,7 +18,7 @@ Puppet::Type.type(:mount).provide(
 
   commands :mountcmd => "mount", :umount => "umount"
 
-  case Facter["operatingsystem"]
+  case Facter.value(:operatingsystem)
   when "Solaris"
     @fields = [:device, :blockdevice, :name, :fstype, :pass, :atboot, :options]
   else

data/lib/puppet/provider/naginator.rb

@@ -30,7 +30,15 @@ class Puppet::Provider::Naginator < Puppet::Provider::ParsedFile
   end
 
   def self.to_file(records)
-    header + records.collect { |record| record.to_s }.join("\n").gsub("_naginator_name", NAME_STRING)
+    header + records.collect { |record|
+        # Remap the TYPE_name or _naginator_name params to the
+        # name if the record is a template (register == 0)
+        if record.to_s =~ /register\s+0/
+            record.to_s.sub("_naginator_name", "name").sub(record.type.to_s + "_name", "name")
+        else
+            record.to_s.sub("_naginator_name", NAME_STRING)
+        end
+    }.join("\n")
   end
 
   def self.skip_record?(record)

data/lib/puppet/provider/nameservice/directoryservice.rb

@@ -235,11 +235,12 @@ class DirectoryService < Puppet::Provider::NameService
     # have a lot of choice. Ultimately this should all be done using Ruby
     # to access the DirectoryService APIs directly, but that's simply not
     # feasible for a while yet.
-    case self.get_macosx_version_major
-    when "10.4"
-      dscl_plist = self.parse_dscl_url_data(dscl_output)
-    when "10.5", "10.6"
+    if self.get_macosx_version_major > "10.4"
       dscl_plist = self.parse_dscl_plist_data(dscl_output)
+    elsif self.get_macosx_version_major == "10.4"
+      dscl_plist = self.parse_dscl_url_data(dscl_output)
+    else
+      fail("Puppet does not support OS X versions < 10.4")
     end
 
     self.generate_attribute_hash(dscl_plist, *type_properties)
@@ -257,12 +258,14 @@ class DirectoryService < Puppet::Provider::NameService
     # different format for the -url output with objects with spaces in
     # their values. *sigh*. Use -url for 10.4 in the hope this can be
     # deprecated one day, and use -plist for 10.5 and higher.
-    case self.get_macosx_version_major
-    when "10.4"
-      command_vector = [ command(:dscl), "-url", "." ]
-    when "10.5", "10.6"
+    if self.get_macosx_version_major > "10.4"
       command_vector = [ command(:dscl), "-plist", "." ]
+    elsif self.get_macosx_version_major == "10.4"
+      command_vector = [ command(:dscl), "-url", "." ]
+    else
+      fail("Puppet does not support OS X versions < 10.4")
     end
+
     # JJM: The actual action to perform.  See "man dscl"
     #      Common actiosn: -create, -delete, -merge, -append, -passwd
     command_vector << ds_action

data/lib/puppet/provider/package/aptitude.rb

@@ -12,6 +12,7 @@ Puppet::Type.type(:package).provide :aptitude, :parent => :apt, :source => :dpkg
     args.flatten!
     # Apparently aptitude hasn't always supported a -q flag.
     args.delete("-q") if args.include?("-q")
+    args.delete("--force-yes") if args.include?("--force-yes")
     output = aptitude(*args)
 
     # Yay, stupid aptitude doesn't throw an error when the package is missing.

data/lib/puppet/rails/host.rb

@@ -1,3 +1,4 @@
+require 'puppet/node/environment'
 require 'puppet/rails'
 require 'puppet/rails/resource'
 require 'puppet/rails/fact_name'
@@ -28,6 +29,12 @@ class Puppet::Rails::Host < ActiveRecord::Base
     host
   end
 
+  # Override the setter for environment to force it to be a string, lest it
+  # be YAML encoded.  See #4487.
+  def environment=(value)
+    super value.to_s
+  end
+
   # returns a hash of fact_names.name => [ fact_values ] for this host.
   # Note that 'fact_values' is actually a list of the value instances, not
   # just actual values.

data/lib/puppet/resource/catalog.rb

@@ -132,16 +132,22 @@ class Puppet::Resource::Catalog < Puppet::SimpleGraph
     expire
 
     Puppet::Util::Storage.load if host_config?
-    transaction = Puppet::Transaction.new(self)
 
-    transaction.report = options[:report] if options[:report]
+    transaction = Puppet::Transaction.new(self, options[:report])
+    register_report = options[:report].nil?
+
     transaction.tags = options[:tags] if options[:tags]
     transaction.ignoreschedules = true if options[:ignoreschedules]
 
     transaction.add_times :config_retrieval => self.retrieval_duration || 0
 
     begin
-      transaction.evaluate
+      Puppet::Util::Log.newdestination(transaction.report) if register_report
+      begin
+        transaction.evaluate
+      ensure
+        Puppet::Util::Log.close(transaction.report) if register_report
+      end
     rescue Puppet::Error => detail
       puts detail.backtrace if Puppet[:trace]
       Puppet.err "Could not apply complete catalog: #{detail}"

data/lib/puppet/transaction.rb

@@ -15,7 +15,7 @@ class Puppet::Transaction
   attr_accessor :sorted_resources, :configurator
 
   # The report, once generated.
-  attr_accessor :report
+  attr_reader :report
 
   # Routes and stores any events and subscriptions.
   attr_reader :event_manager
@@ -123,31 +123,23 @@ class Puppet::Transaction
   # collects all of the changes, executes them, and responds to any
   # necessary events.
   def evaluate
-    # Start logging.
-    Puppet::Util::Log.newdestination(@report)
-
     prepare
 
     Puppet.info "Applying configuration version '#{catalog.version}'" if catalog.version
 
-    begin
-      @sorted_resources.each do |resource|
-        next if stop_processing?
-        if resource.is_a?(Puppet::Type::Component)
-          Puppet.warning "Somehow left a component in the relationship graph"
-          next
-        end
-        ret = nil
-        seconds = thinmark do
-          ret = eval_resource(resource)
-        end
-
-        resource.info "Evaluated in %0.2f seconds" % seconds if Puppet[:evaltrace] and @catalog.host_config?
-        ret
+    @sorted_resources.each do |resource|
+      next if stop_processing?
+      if resource.is_a?(Puppet::Type::Component)
+        Puppet.warning "Somehow left a component in the relationship graph"
+        next
       end
-    ensure
-      # And then close the transaction log.
-      Puppet::Util::Log.close(@report)
+      ret = nil
+      seconds = thinmark do
+        ret = eval_resource(resource)
+      end
+
+      resource.info "valuated in %0.2f seconds" % seconds if Puppet[:evaltrace] and @catalog.host_config?
+      ret
     end
 
     Puppet.debug "Finishing transaction #{object_id}"
@@ -228,13 +220,10 @@ class Puppet::Transaction
 
   # this should only be called by a Puppet::Type::Component resource now
   # and it should only receive an array
-  def initialize(catalog)
+  def initialize(catalog, report = nil)
     @catalog = catalog
-
-    @report = Report.new("apply", catalog.version)
-
+    @report = report || Report.new("apply", catalog.version)
     @event_manager = Puppet::Transaction::EventManager.new(self)
-
     @resource_harness = Puppet::Transaction::ResourceHarness.new(self)
   end
 

data/lib/puppet/transaction/report.rb

@@ -10,8 +10,8 @@ class Puppet::Transaction::Report
 
   indirects :report, :terminus_class => :processor
 
-  attr_accessor :configuration_version
-  attr_reader :resource_statuses, :logs, :metrics, :host, :time, :kind, :status
+  attr_accessor :configuration_version, :host
+  attr_reader :resource_statuses, :logs, :metrics, :time, :kind, :status
 
   # This is necessary since Marshall doesn't know how to
   # dump hash with default proc (see below @records)
@@ -67,7 +67,7 @@ class Puppet::Transaction::Report
     @logs = []
     @resource_statuses = {}
     @external_times ||= {}
-    @host = Puppet[:certname]
+    @host = Puppet[:node_name_value]
     @time = Time.now
     @kind = kind
     @report_format = 2

data/lib/puppet/type.rb

@@ -1416,9 +1416,8 @@ class Type
   def self.provide(name, options = {}, &block)
     name = Puppet::Util.symbolize(name)
 
-    if obj = provider_hash[name]
+    if unprovide(name)
       Puppet.debug "Reloading #{name} #{self.name} provider"
-      unprovide(name)
     end
 
     parent = if pname = options[:parent]
@@ -1441,16 +1440,14 @@ class Type
 
     self.providify
 
-
-      provider = genclass(
-        name,
-      :parent => parent,
-      :hash => provider_hash,
-      :prefix => "Provider",
-      :block => block,
-      :include => feature_module,
-      :extend => feature_module,
-
+    provider = genclass(
+      name,
+      :parent     => parent,
+      :hash       => provider_hash,
+      :prefix     => "Provider",
+      :block      => block,
+      :include    => feature_module,
+      :extend     => feature_module,
       :attributes => options
     )
 
@@ -1510,18 +1507,11 @@ class Type
   end
 
   def self.unprovide(name)
-    if provider_hash.has_key? name
-
-      rmclass(
-        name,
-        :hash => provider_hash,
-
-        :prefix => "Provider"
-      )
-      if @defaultprovider and @defaultprovider.name == name
-        @defaultprovider = nil
-      end
+    if @defaultprovider and @defaultprovider.name == name
+      @defaultprovider = nil
     end
+
+    rmclass(name, :hash => provider_hash, :prefix => "Provider")
   end
 
   # Return an array of all of the suitable providers.
@@ -1581,7 +1571,6 @@ class Type
 
       # Collect the current prereqs
       list.each { |dep|
-        obj = nil
         # Support them passing objects directly, to save some effort.
         unless dep.is_a? Puppet::Type
           # Skip autorequires that we aren't managing

data/lib/puppet/util/queue.rb

@@ -30,7 +30,7 @@ require 'puppet/util/instance_loader'
 #
 # The client plugins are expected to implement an interface similar to that of Stomp::Client:
 # * <tt>new</tt> should return a connected, ready-to-go client instance.  Note that no arguments are passed in.
-# * <tt>send_message(queue, message)</tt> should send the _message_ to the specified _queue_.
+# * <tt>publish_message(queue, message)</tt> should publish the _message_ to the specified _queue_.
 # * <tt>subscribe(queue)</tt> _block_ subscribes to _queue_ and executes _block_ upon receiving a message.
 # * _queue_ names are simple names independent of the message broker or client library.  No "/queue/" prefixes like in Stomp::Client.
 module Puppet::Util::Queue

data/lib/puppet/util/queue/stomp.rb

@@ -28,8 +28,8 @@ class Puppet::Util::Queue::Stomp
     end
   end
 
-  def send_message(target, msg)
-    stomp_client.send(stompify_target(target), msg, :persistent => true)
+  def publish_message(target, msg)
+    stomp_client.publish(stompify_target(target), msg, :persistent => true)
   end
 
   def subscribe(target)

data/lib/puppet/util/settings/file_setting.rb

@@ -101,6 +101,7 @@ class Puppet::Util::Settings::FileSetting < Puppet::Util::Settings::Setting
 
     resource[:ensure] = type
     resource[:loglevel] = :debug
+    resource[:links] = :follow
     resource[:backup] = false
 
     resource.tag(self.section, self.name, "settings")

data/spec/integration/defaults_spec.rb

@@ -23,6 +23,28 @@ describe "Puppet defaults" do
     end
   end
 
+  describe "when setting :node_name_value" do
+    it "should default to the value of :certname" do
+      Puppet.settings[:certname] = 'blargle'
+      Puppet.settings[:node_name_value].should == 'blargle'
+    end
+  end
+
+  describe "when setting the :node_name_fact" do
+    it "should fail when also setting :node_name_value" do
+      lambda do
+        Puppet.settings[:node_name_value] = "some value"
+        Puppet.settings[:node_name_fact] = "some_fact"
+      end.should raise_error("Cannot specify both the node_name_value and node_name_fact settings")
+    end
+
+    it "should not fail when using the default for :node_name_value" do
+      lambda do
+        Puppet.settings[:node_name_fact] = "some_fact"
+      end.should_not raise_error
+    end
+  end
+
   describe "when configuring the :crl" do
     it "should warn if :cacrl is set to false" do
       Puppet.expects(:warning)

data/spec/integration/indirector/catalog/queue_spec.rb

@@ -20,13 +20,13 @@ describe "Puppet::Resource::Catalog::Queue", :if => Puppet.features.pson? do
 
   after { Puppet.settings.clear }
 
-  it "should render catalogs to pson and send them via the queue client when catalogs are saved" do
+  it "should render catalogs to pson and publish them via the queue client when catalogs are saved" do
     terminus = Puppet::Resource::Catalog.indirection.terminus(:queue)
 
     client = mock 'client'
     terminus.stubs(:client).returns client
 
-    client.expects(:send_message).with(:catalog, @catalog.to_pson)
+    client.expects(:publish_message).with(:catalog, @catalog.to_pson)
 
     request = Puppet::Indirector::Request.new(:catalog, :save, "foo", :instance => @catalog)
 

data/spec/integration/type_spec.rb

@@ -19,4 +19,15 @@ describe Puppet::Type do
 
     type.provider(:myprovider).should equal(provider)
   end
+
+  it "should not lose its provider parameter when it is reloaded" do
+    type = Puppet::Type.newtype(:reload_test_type)
+
+    provider = type.provide(:test_provider)
+
+    # reload it
+    type = Puppet::Type.newtype(:reload_test_type)
+
+    type.parameters.should include(:provider)
+  end
 end

data/spec/unit/application/agent_spec.rb

@@ -411,7 +411,7 @@ describe Puppet::Application::Agent do
 
     describe "when setting up listen" do
       before :each do
-        Puppet.stubs(:[]).with(:authconfig).returns('auth')
+        Puppet.stubs(:[]).with(:rest_authconfig).returns('auth')
         FileTest.stubs(:exists?).with('auth').returns(true)
         File.stubs(:exist?).returns(true)
         @puppetd.options.stubs(:[]).with(:serve).returns([])
@@ -570,7 +570,7 @@ describe Puppet::Application::Agent do
         @host.stubs(:certificate).returns(@cert)
         @cert.stubs(:fingerprint).with(:MD5).returns("DIGEST")
 
-        Puppet.expects(:notice).with("DIGEST")
+        @puppetd.expects(:puts).with "DIGEST"
 
         @puppetd.fingerprint
       end

data/spec/unit/application/apply_spec.rb

@@ -5,6 +5,7 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/application/apply'
 require 'puppet/file_bucket/dipper'
 require 'puppet/configurer'
+require 'fileutils'
 
 describe Puppet::Application::Apply do
   before :each do
@@ -182,38 +183,39 @@ describe Puppet::Application::Apply do
     end
 
     describe "the main command" do
+      include PuppetSpec::Files
+
       before :each do
-        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[:prerun_command] = ''
+        Puppet[:postrun_command] = ''
 
-        @apply.options.stubs(:[])
+        Puppet::Node::Facts.terminus_class = :memory
+        Puppet::Node.terminus_class = :memory
 
-        @facts = stub_everything 'facts'
-        Puppet::Node::Facts.stubs(:find).returns(@facts)
+        @facts = Puppet::Node::Facts.new(Puppet[:node_name_value])
+        @facts.save
 
-        @node = stub_everything 'node'
-        Puppet::Node.stubs(:find).returns(@node)
+        @node = Puppet::Node.new(Puppet[:node_name_value])
+        @node.save
 
-        @catalog = stub_everything 'catalog'
+        @catalog = Puppet::Resource::Catalog.new
         @catalog.stubs(:to_ral).returns(@catalog)
+
         Puppet::Resource::Catalog.stubs(:find).returns(@catalog)
 
         STDIN.stubs(:read)
 
-        @transaction = stub_everything 'transaction'
-        @catalog.stubs(:apply).returns(@transaction)
-
         @apply.stubs(:exit)
 
+        @transaction = Puppet::Transaction.new(@catalog)
+        @catalog.stubs(:apply).returns(@transaction)
+
         Puppet::Util::Storage.stubs(:load)
         Puppet::Configurer.any_instance.stubs(:save_last_run_summary) # to prevent it from trying to write files
       end
 
       it "should set the code to run from --code" do
-        @apply.options.stubs(:[]).with(:code).returns("code to run")
+        @apply.options[:code] = "code to run"
         Puppet.expects(:[]=).with(:code,"code to run")
 
         @apply.main
@@ -229,47 +231,58 @@ describe Puppet::Application::Apply do
       end
 
       it "should set the manifest if a file is passed on command line and the file exists" do
-        File.stubs(:exist?).with('site.pp').returns true
-        @apply.command_line.stubs(:args).returns(['site.pp'])
+        manifest = tmpfile('site.pp')
+        FileUtils.touch(manifest)
+        @apply.command_line.stubs(:args).returns([manifest])
 
-        Puppet.expects(:[]=).with(:manifest,"site.pp")
+        Puppet.expects(:[]=).with(:manifest,manifest)
 
         @apply.main
       end
 
       it "should raise an error if a file is passed on command line and the file does not exist" do
-        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')
+        noexist = tmpfile('noexist.pp')
+        @apply.command_line.stubs(:args).returns([noexist])
+        lambda { @apply.main }.should raise_error(RuntimeError, "Could not find file #{noexist}")
       end
 
       it "should set the manifest to the first file and warn other files will be skipped" do
-        File.stubs(:exist?).with('starwarsIV').returns true
-        File.expects(:exist?).with('starwarsI').never
-        @apply.command_line.stubs(:args).returns(['starwarsIV', 'starwarsI', 'starwarsII'])
+        manifest = tmpfile('starwarsIV')
+        FileUtils.touch(manifest)
+
+        @apply.command_line.stubs(:args).returns([manifest, 'starwarsI', 'starwarsII'])
 
-        Puppet.expects(:[]=).with(:manifest,"starwarsIV")
+        Puppet.expects(:[]=).with(:manifest,manifest)
         Puppet.expects(:warning).with('Only one file can be applied per run.  Skipping starwarsI, starwarsII')
 
         @apply.main
       end
 
-      it "should collect the node facts" do
-        Puppet::Node::Facts.expects(:find).returns(@facts)
+      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'
 
         @apply.main
+
+        @facts.name.should == 'other_node_name'
       end
 
-      it "should raise an error if we can't find the node" do
-        Puppet::Node::Facts.expects(:find).returns(nil)
+      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'
 
-        lambda { @apply.main }.should raise_error
+        @apply.main
+
+        Puppet[:node_name_value].should == 'other_node_name'
       end
 
-      it "should look for the node" do
-        Puppet::Node.expects(:find).returns(@node)
+      it "should raise an error if we can't find the facts" do
+        Puppet::Node::Facts.expects(:find).returns(nil)
 
-        @apply.main
+        lambda { @apply.main }.should raise_error
       end
 
       it "should raise an error if we can't find the node" do
@@ -279,21 +292,20 @@ describe Puppet::Application::Apply do
       end
 
       it "should merge in our node the loaded facts" do
-        @facts.stubs(:values).returns("values")
-
-        @node.expects(:merge).with("values")
+        @facts.values = {'key' => 'value'}
 
         @apply.main
+
+        @node.parameters['key'].should == 'value'
       end
 
       it "should load custom classes if loadclasses" do
-        @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")
+        @apply.options[:loadclasses] = true
+        classfile = tmpfile('classfile')
+        File.open(classfile, 'w') { |c| c.puts 'class' }
+        Puppet[:classfile] = classfile
 
-        @node.expects(:classes=)
+        @node.expects(:classes=).with(['class'])
 
         @apply.main
       end
@@ -331,9 +343,12 @@ describe Puppet::Application::Apply do
       end
 
       describe "with detailed_exitcodes" do
+        before :each do
+          @apply.options[:detailed_exitcodes] = true
+        end
+
         it "should exit with report's computed exit status" do
-          Puppet.stubs(:[]).with(:noop).returns(false)
-          @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
+          Puppet[:noop] = false
           Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
           @apply.expects(:exit).with(666)
 
@@ -341,8 +356,7 @@ describe Puppet::Application::Apply do
         end
 
         it "should exit with report's computed exit status, even if --noop is set" do
-          Puppet.stubs(:[]).with(:noop).returns(true)
-          @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
+          Puppet[:noop] = true
           Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
           @apply.expects(:exit).with(666)
 
@@ -350,8 +364,7 @@ describe Puppet::Application::Apply do
         end
 
         it "should always exit with 0 if option is disabled" do
-          Puppet.stubs(:[]).with(:noop).returns(false)
-          @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(false)
+          Puppet[:noop] = false
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(0)
@@ -360,8 +373,7 @@ describe Puppet::Application::Apply do
         end
 
         it "should always exit with 0 if --noop" do
-          Puppet.stubs(:[]).with(:noop).returns(true)
-          @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
+          Puppet[:noop] = true
           report = stub 'report', :exit_status => 666
           @transaction.stubs(:report).returns(report)
           @apply.expects(:exit).with(0)