puppet 3.1.1 → 3.2.0.rc1

data/spec/unit/indirector/indirection_spec.rb

@@ -229,6 +229,11 @@ describe Puppet::Indirector::Indirection do
         @indirection.find("me").should equal(@instance)
       end
 
+      it "should return false if the instance is false" do
+        @terminus.expects(:find).returns(false)
+        @indirection.find("me").should equal(false)
+      end
+
       it "should set the expiration date on any instances without one set" do
         @terminus.stubs(:find).returns(@instance)
 

data/spec/unit/indirector/resource/active_record_spec.rb

@@ -1,40 +1,27 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-require 'puppet/rails'
 require 'puppet/node/facts'
 
 describe "Puppet::Resource::ActiveRecord", :if => can_use_scratch_database? do
   include PuppetSpec::Files
 
   before :each do
+    require 'puppet/indirector/resource/active_record'
     setup_scratch_database
-    Puppet[:storeconfigs] = true
   end
 
-  subject {
-    require 'puppet/indirector/resource/active_record'
-    Puppet::Resource.indirection.terminus(:active_record)
-  }
-
-  it "should automatically initialize Rails" do
-    # Other tests in the suite may have established the connection, which will
-    # linger; the assertion is just to enforce our assumption about the call,
-    # not because I *really* want to test ActiveRecord works.  Better to have
-    # an early failure than wonder why the test overall doesn't DTRT.
-    ActiveRecord::Base.remove_connection
-    ActiveRecord::Base.should_not be_connected
-    subject.should be
-    ActiveRecord::Base.should be_connected
+  after :each do
+    Puppet::Rails.teardown
   end
 
+  subject { Puppet::Resource.indirection.terminus(:active_record) }
+
   it "should issue a deprecation warning" do
     Puppet.expects(:deprecation_warning).with() { |msg| msg =~ /ActiveRecord-based storeconfigs and inventory are deprecated/ }
     Puppet::Resource::ActiveRecord.new
   end
 
   describe "#search" do
-    before :each do Puppet::Rails.init end
-
     def search(type, host = 'default.local', filter = nil)
       args = { :host => host, :filter => filter }
       subject.search(Puppet::Resource.indirection.request(:search, type, nil, args))
@@ -79,10 +66,6 @@ describe "Puppet::Resource::ActiveRecord", :if => can_use_scratch_database? do
   end
 
   describe "#build_active_record_query" do
-    before :each do
-      Puppet::Rails.init
-    end
-
     let :type do 'Notify' end
 
     def query(type, host, filter = nil)

data/spec/unit/indirector_spec.rb

@@ -79,6 +79,12 @@ describe Puppet::Indirector, "when registering an indirection" do
   before do
     @thingie = Class.new do
       extend Puppet::Indirector
+
+      # override Class#name, since we're not naming this ephemeral class
+      def self.name
+        'Thingie'
+      end
+
       attr_reader :name
       def initialize(name)
         @name = name
@@ -108,7 +114,7 @@ describe Puppet::Indirector, "when registering an indirection" do
 
   it "should pass any provided options to the indirection during initialization" do
     klass = mock 'terminus class'
-    Puppet::Indirector::Indirection.expects(:new).with(@thingie, :first, {:some => :options})
+    Puppet::Indirector::Indirection.expects(:new).with(@thingie, :first, {:some => :options, :indirected_class => 'Thingie'})
     @indirection = @thingie.indirects :first, :some => :options
   end
 

data/spec/unit/interface/action_builder_spec.rb

@@ -1,6 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-require 'puppet/interface/action_builder'
+require 'puppet/interface'
 require 'puppet/network/format_handler'
 
 describe Puppet::Interface::ActionBuilder do

data/spec/unit/interface/action_manager_spec.rb

@@ -1,9 +1,7 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 
-# This is entirely an internal class for Interface, so we have to load it instead of our class.
 require 'puppet/interface'
-require 'puppet/face'
 
 class ActionManagerTester
   include Puppet::Interface::ActionManager

data/spec/unit/interface/action_spec.rb

@@ -1,6 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
-require 'puppet/interface/action'
+require 'puppet/interface'
 
 describe Puppet::Interface::Action do
   describe "when validating the action name" do

data/spec/unit/interface/documentation_spec.rb

@@ -1,8 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/interface'
-require 'puppet/interface/option'
-require 'puppet/interface/documentation'
 
 class Puppet::Interface::TinyDocs::Test
   include Puppet::Interface::TinyDocs

data/spec/unit/interface/face_collection_spec.rb

@@ -2,7 +2,7 @@
 require 'spec_helper'
 
 require 'tmpdir'
-require 'puppet/interface/face_collection'
+require 'puppet/interface'
 
 describe Puppet::Interface::FaceCollection do
   # To avoid cross-pollution we have to save and restore both the hash

data/spec/unit/interface/option_builder_spec.rb

@@ -1,4 +1,4 @@
-require 'puppet/interface/option_builder'
+require 'puppet/interface'
 
 describe Puppet::Interface::OptionBuilder do
   let :face do Puppet::Interface.new(:option_builder_testing, '0.0.1') end

data/spec/unit/interface/option_spec.rb

@@ -1,5 +1,4 @@
 require 'puppet/interface'
-require 'puppet/interface/option'
 
 describe Puppet::Interface::Option do
   let :face do Puppet::Interface.new(:option_testing, '0.0.1') end

data/spec/unit/module_spec.rb

@@ -592,30 +592,28 @@ describe Puppet::Module do
   end
 
   it "should be able to tell if there are local changes" do
-    pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-      modpath = tmpdir('modpath')
-      foo_checksum = 'acbd18db4cc2f85cedef654fccc4a4d8'
-      checksummed_module = PuppetSpec::Modules.create(
-        'changed',
-        modpath,
-        :metadata => {
-          :checksums => {
-            "foo" => foo_checksum,
-          }
+    modpath = tmpdir('modpath')
+    foo_checksum = 'acbd18db4cc2f85cedef654fccc4a4d8'
+    checksummed_module = PuppetSpec::Modules.create(
+      'changed',
+      modpath,
+      :metadata => {
+        :checksums => {
+          "foo" => foo_checksum,
         }
-      )
+      }
+    )
 
-      foo_path = Pathname.new(File.join(checksummed_module.path, 'foo'))
+    foo_path = Pathname.new(File.join(checksummed_module.path, 'foo'))
 
-      IO.binwrite(foo_path, 'notfoo')
-      Puppet::ModuleTool::Checksums.new(foo_path).checksum(foo_path).should_not == foo_checksum
-      checksummed_module.has_local_changes?.should be_true
+    IO.binwrite(foo_path, 'notfoo')
+    Puppet::ModuleTool::Checksums.new(foo_path).checksum(foo_path).should_not == foo_checksum
+    checksummed_module.has_local_changes?.should be_true
 
-      IO.binwrite(foo_path, 'foo')
+    IO.binwrite(foo_path, 'foo')
 
-      Puppet::ModuleTool::Checksums.new(foo_path).checksum(foo_path).should == foo_checksum
-      checksummed_module.has_local_changes?.should be_false
-    end
+    Puppet::ModuleTool::Checksums.new(foo_path).checksum(foo_path).should == foo_checksum
+    checksummed_module.has_local_changes?.should be_false
   end
 
   it "should know what other modules require it" do

data/spec/unit/module_tool/application_spec.rb

@@ -12,9 +12,7 @@ describe Puppet::ModuleTool::Applications::Application do
 
     good_versions.each do |ver|
       it "should accept version string #{ver}" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          app.parse_filename("puppetlabs-ntp-#{ver}")
-        end
+        app.parse_filename("puppetlabs-ntp-#{ver}")
       end
     end
 

data/spec/unit/module_tool/applications/builder_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'puppet/module_tool/applications'
+require 'puppet_spec/modules'
+
+describe Puppet::ModuleTool::Applications::Builder do
+  include PuppetSpec::Files
+
+  let(:path)         { tmpdir("working_dir") }
+  let(:module_name)  { 'myusername-mytarball' }
+  let(:version)      { '0.0.1' }
+  let(:release_name) { "#{module_name}-#{version}" }
+  let(:tarball)      { File.join(path, 'pkg', release_name) + ".tar.gz" }
+  let(:builder)      { Puppet::ModuleTool::Applications::Builder.new(path) }
+
+  before :each do
+    File.open(File.join(path, 'Modulefile'), 'w') do |f|
+      f.write(<<EOM)
+name    '#{module_name}'
+version '#{version}'
+source 'http://github.com/testing/#{module_name}'
+author 'testing'
+license 'Apache License Version 2.0'
+summary 'Puppet testing module'
+description 'This module can be used for basic testing'
+project_page 'http://github.com/testing/#{module_name}'
+EOM
+    end
+  end
+
+  it "should attempt to create a module relative to the pkg directory" do
+    tarrer = mock('tarrer')
+    Puppet::ModuleTool::Tar.expects(:instance).with(module_name).returns(tarrer)
+    Dir.expects(:chdir).with(File.join(path, 'pkg')).yields
+    tarrer.expects(:pack).with(release_name, tarball)
+
+    builder.run
+  end
+end

data/spec/unit/module_tool/applications/checksummer_spec.rb

@@ -0,0 +1,134 @@
+require 'spec_helper'
+require 'puppet/module_tool/applications'
+
+describe Puppet::ModuleTool::Applications::Checksummer, :unless => Puppet.features.microsoft_windows? do
+  subject {
+    Puppet::ModuleTool::Applications::Checksummer.new(module_install_path)
+  }
+
+  let(:module_install_path) { 'foo' }
+  let(:module_metadata_file) { 'metadata.json' }
+
+  let(:module_install_pathname) {
+    module_install_pathname = mock()
+    Pathname.expects(:new).with(module_install_path).\
+      returns(module_install_pathname)
+    module_install_pathname
+  }
+
+  def stub_module_file_pathname(relative_path, present)
+    module_file_pathname = mock() do
+      expects(:exist?).with().returns(present)
+    end
+
+    module_install_pathname.expects(:+).with(relative_path).\
+      returns(module_file_pathname)
+
+    module_file_pathname
+  end
+
+  context %q{when metadata.json doesn't exist in the specified module install path} do
+    before(:each) do
+      stub_module_file_pathname(module_metadata_file, false)
+      subject.expects(:metadata_file).with().\
+        returns(module_install_pathname + module_metadata_file)
+    end
+
+    it 'raises an ArgumentError exception' do
+      lambda {
+        subject.run
+      }.should raise_error(ArgumentError, 'No metadata.json found.')
+    end
+  end
+
+  context 'when metadata.json exists in the specified module install path' do
+    module_files = {
+      'README'     => '1',
+      'CHANGELOG'  => '2',
+      'Modulefile' => '3',
+    }
+    let(:module_files) { module_files }
+    let(:checksum_computer) {
+      checksum_computer = mock()
+      Puppet::ModuleTool::Checksums.\
+        expects(:new).with(module_install_pathname).\
+        returns(checksum_computer)
+      checksum_computer
+    }
+    # all possible combinations (of all lengths) of the module files
+    module_files_combination =
+      1.upto(module_files.size()).inject([]) { |module_files_combination, n|
+        module_files.keys.combination(n) { |combination|
+          module_files_combination << combination
+        }
+        module_files_combination
+      }
+
+    def stub_module_file_pathname_with_checksum(relative_path, checksum)
+      module_file_pathname =
+        stub_module_file_pathname(relative_path, present = !checksum.nil?)
+      # mock the call of Puppet::ModuleTool::Checksums#checksum
+      expectation = checksum_computer.\
+        expects(:checksum).with(module_file_pathname)
+      if present
+        # return the cheksum directly
+        expectation.returns(checksum)
+      else
+        # if the file is not present, then the method should not be called
+        expectation.times(0)
+      end
+      module_file_pathname
+    end
+
+    def stub_module_files(overrides = {})
+      overrides.reject! { |key, value|
+        !module_files.include?(key)
+      }
+      module_files.merge(overrides).each { |relative_path, checksum|
+        stub_module_file_pathname_with_checksum(relative_path, checksum)
+      }
+    end
+
+    before(:each) do
+      stub_module_file_pathname(module_metadata_file, true)
+      subject.expects(:metadata_file).with().\
+        returns(module_install_pathname + module_metadata_file)
+      subject.expects(:metadata).with().\
+        returns({ 'checksums' => module_files })
+    end
+
+    module_files_combination.each do |removed_files|
+      it "reports removed file(s) #{removed_files.inspect}" do
+        stub_module_files(
+          removed_files.inject({}) { |overrides, removed_file|
+            overrides[removed_file] = nil
+            overrides
+          }
+        )
+
+        subject.run.should == removed_files
+      end
+    end
+
+    module_files_combination.each do |modified_files|
+      it "reports modified file(s) #{modified_files.inspect}" do
+        stub_module_files(
+          modified_files.inject({}) { |overrides, modified_file|
+            modified_checksum = module_files[modified_file].to_s.succ
+            modified_checksum = ' ' if modified_checksum.empty?
+            overrides[modified_file] = modified_checksum
+            overrides
+          }
+        )
+
+        subject.run.should == modified_files
+      end
+    end
+
+    it 'does not report unmodified files' do
+      stub_module_files()
+
+      subject.run.should == []
+    end
+  end
+end

data/spec/unit/module_tool/applications/installer_spec.rb

@@ -3,7 +3,7 @@ require 'puppet/module_tool/applications'
 require 'puppet_spec/modules'
 require 'semver'
 
-describe Puppet::ModuleTool::Applications::Installer, :fails_on_windows => true do
+describe Puppet::ModuleTool::Applications::Installer, :unless => Puppet.features.microsoft_windows? do
   include PuppetSpec::Files
 
   before do
@@ -80,18 +80,14 @@ describe Puppet::ModuleTool::Applications::Installer, :fails_on_windows => true
 
   describe "the behavior of .is_module_package?" do
     it "should return true when file is a module package" do
-      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-        installer = installer_class.new("foo", forge, install_dir, options)
-        installer.send(:is_module_package?, stdlib_pkg).should be_true
-      end
+      installer = installer_class.new("foo", forge, install_dir, options)
+      installer.send(:is_module_package?, stdlib_pkg).should be_true
     end
 
     it "should return false when file is not a module package" do
-      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-        installer = installer_class.new("foo", forge, install_dir, options)
-        installer.send(:is_module_package?, "pmtacceptance-apollo-0.0.2.tar").
-          should be_false
-      end
+      installer = installer_class.new("foo", forge, install_dir, options)
+      installer.send(:is_module_package?, "pmtacceptance-apollo-0.0.2.tar").
+        should be_false
     end
   end
 
@@ -102,15 +98,13 @@ describe Puppet::ModuleTool::Applications::Installer, :fails_on_windows => true
     end
 
     it "should install the requested module" do
-      pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-          with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
-          returns(unpacker)
-        results = installer_class.run('pmtacceptance-stdlib', forge, install_dir, options)
-        results[:installed_modules].length == 1
-        results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
-        results[:installed_modules][0][:version][:vstring].should == "1.0.0"
-      end
+      Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+        with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
+        returns(unpacker)
+      results = installer_class.run('pmtacceptance-stdlib', forge, install_dir, options)
+      results[:installed_modules].length == 1
+      results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
+      results[:installed_modules][0][:version][:vstring].should == "1.0.0"
     end
 
     context "should check the target directory" do
@@ -129,98 +123,85 @@ describe Puppet::ModuleTool::Applications::Installer, :fails_on_windows => true
       end
 
       it "(#15202) prepares the install directory" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          expect_normal_unpacker
-          install_dir.expects(:prepare).with("pmtacceptance-stdlib", "latest")
+        expect_normal_unpacker
+        install_dir.expects(:prepare).with("pmtacceptance-stdlib", "latest")
 
-          results = installer.run
+        results = installer.run
 
-          results[:installed_modules].length.should eq 1
-          results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
-          results[:installed_modules][0][:version][:vstring].should == "1.0.0"
-        end
+        results[:installed_modules].length.should eq 1
+        results[:installed_modules][0][:module].should == "pmtacceptance-stdlib"
+        results[:installed_modules][0][:version][:vstring].should == "1.0.0"
       end
 
       it "(#15202) reports an error when the install directory cannot be prepared" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          install_dir.expects(:prepare).with("pmtacceptance-stdlib", "latest").
-            raises(Puppet::ModuleTool::Errors::PermissionDeniedCreateInstallDirectoryError.new("original", :module => "pmtacceptance-stdlib"))
+        install_dir.expects(:prepare).with("pmtacceptance-stdlib", "latest").
+          raises(Puppet::ModuleTool::Errors::PermissionDeniedCreateInstallDirectoryError.new("original", :module => "pmtacceptance-stdlib"))
 
-          results = installer.run
+        results = installer.run
 
-          results[:result].should == :failure
-          results[:error][:oneline].should =~ /Permission is denied/
-        end
+        results[:result].should == :failure
+        results[:error][:oneline].should =~ /Permission is denied/
       end
     end
 
     context "when the requested module has dependencies" do
       it "should install dependencies" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-            with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
-            returns(unpacker)
-          Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-            with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
-            returns(unpacker)
-          Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-            with('/fake_cache/pmtacceptance-java-1.7.1.tar.gz', options).
-            returns(unpacker)
-
-          results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
-          installed_dependencies = results[:installed_modules][0][:dependencies]
-
-          dependencies = installed_dependencies.inject({}) do |result, dep|
-            result[dep[:module]] = dep[:version][:vstring]
-            result
-          end
-
-          dependencies.length.should == 2
-          dependencies['pmtacceptance-java'].should   == '1.7.1'
-          dependencies['pmtacceptance-stdlib'].should == '1.0.0'
+        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+          with('/fake_cache/pmtacceptance-stdlib-1.0.0.tar.gz', options).
+          returns(unpacker)
+        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+          with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
+          returns(unpacker)
+        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+          with('/fake_cache/pmtacceptance-java-1.7.1.tar.gz', options).
+          returns(unpacker)
+
+        results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
+        installed_dependencies = results[:installed_modules][0][:dependencies]
+
+        dependencies = installed_dependencies.inject({}) do |result, dep|
+          result[dep[:module]] = dep[:version][:vstring]
+          result
         end
+
+        dependencies.length.should == 2
+        dependencies['pmtacceptance-java'].should   == '1.7.1'
+        dependencies['pmtacceptance-stdlib'].should == '1.0.0'
       end
 
       it "should install requested module if the '--force' flag is used" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          options = { :force => true, :target_dir => modpath1 }
-          Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-            with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
-            returns(unpacker)
-          results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
-          results[:installed_modules][0][:module].should == "pmtacceptance-apollo"
-        end
+        options = { :force => true, :target_dir => modpath1 }
+        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+          with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
+          returns(unpacker)
+        results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
+        results[:installed_modules][0][:module].should == "pmtacceptance-apollo"
       end
 
       it "should not install dependencies if the '--force' flag is used" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          options = { :force => true, :target_dir => modpath1 }
-          Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-            with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
-            returns(unpacker)
-          results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
-          dependencies = results[:installed_modules][0][:dependencies]
-          dependencies.should == []
-        end
+        options = { :force => true, :target_dir => modpath1 }
+        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+          with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
+          returns(unpacker)
+        results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
+        dependencies = results[:installed_modules][0][:dependencies]
+        dependencies.should == []
       end
 
       it "should not install dependencies if the '--ignore-dependencies' flag is used" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          options = { :ignore_dependencies => true, :target_dir => modpath1 }
-          Puppet::ModuleTool::Applications::Unpacker.expects(:new).
-            with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
-            returns(unpacker)
-          results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
-          dependencies = results[:installed_modules][0][:dependencies]
-          dependencies.should == []
-        end
+        options = { :ignore_dependencies => true, :target_dir => modpath1 }
+        Puppet::ModuleTool::Applications::Unpacker.expects(:new).
+          with('/fake_cache/pmtacceptance-apollo-0.0.2.tar.gz', options).
+          returns(unpacker)
+        results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
+        dependencies = results[:installed_modules][0][:dependencies]
+        dependencies.should == []
       end
 
       it "should set an error if dependencies can't be resolved" do
-        pending("porting to Windows", :if => Puppet.features.microsoft_windows?) do
-          options = { :version => '0.0.1', :target_dir => modpath1 }
-          oneline = "'pmtacceptance-apollo' (v0.0.1) requested; Invalid dependency cycle"
-          multiline = <<-MSG.strip
+        options = { :version => '0.0.1', :target_dir => modpath1 }
+        oneline = "'pmtacceptance-apollo' (v0.0.1) requested; Invalid dependency cycle"
+        multiline = <<-MSG.strip
 Could not install module 'pmtacceptance-apollo' (v0.0.1)
   No version of 'pmtacceptance-stdlib' will satisfy dependencies
     You specified 'pmtacceptance-apollo' (v0.0.1),
@@ -229,11 +210,10 @@ Could not install module 'pmtacceptance-apollo' (v0.0.1)
     Use `puppet module install --force` to install this module anyway
 MSG
 
-          results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
-          results[:result].should == :failure
-          results[:error][:oneline].should == oneline
-          results[:error][:multiline].should == multiline
-        end
+        results = installer_class.run('pmtacceptance-apollo', forge, install_dir, options)
+        results[:result].should == :failure
+        results[:error][:oneline].should == oneline
+        results[:error][:multiline].should == multiline
       end
     end