puppet 2.7.18 → 2.7.19

data/spec/unit/indirector/rest_spec.rb

@@ -93,36 +93,47 @@ describe Puppet::Indirector::REST do
   describe "when making http requests" do
     include PuppetSpec::Files
 
-    it "should provide a suggestive error message when certificate verify failed" do
+    def a_connection_that_verifies(args)
       connection = Net::HTTP.new('my_server', 8140)
-      @searcher.stubs(:network).returns(connection)
+      connection.stubs(:get).with do
+        connection.verify_callback.call(args[:has_passed_pre_checks], args[:in_context])
+        true
+      end.raises(OpenSSL::SSL::SSLError.new(args[:fails_with]))
+      connection
+    end
 
-      connection.stubs(:get).raises(OpenSSL::SSL::SSLError.new('certificate verify failed'))
+    def a_store_context(args)
+      Puppet[:confdir] = tmpdir('conf')
+      cert = Puppet::SSL::CertificateAuthority.new.generate(args[:for_server], :dns_alt_names => args[:for_aliases]).content
+      ssl_context = mock('OpenSSL::X509::StoreContext')
+      ssl_context.stubs(:current_cert).returns(cert)
+      ssl_context.stubs(:error_string).returns(args[:with_error_string])
+      ssl_context
+    end
 
+    it "should provide a useful error message when one is available and certificate validation fails", :unless => Puppet.features.microsoft_windows? do
+      @searcher.stubs(:network).
+        returns(a_connection_that_verifies(:has_passed_pre_checks => false,
+                                           :in_context => a_store_context(:for_server => 'not_my_server',
+                                                                          :with_error_string => 'shady looking signature'),
+                                           :fails_with => 'certificate verify failed'))
       expect do
         @searcher.http_request(:get, stub('request'))
-      end.to raise_error(/This is often because the time is out of sync on the server or client/)
+      end.to raise_error(Puppet::Error, "certificate verify failed: [shady looking signature for /CN=not_my_server]")
     end
 
     it "should provide a helpful error message when hostname was not match with server certificate", :unless => Puppet.features.microsoft_windows? do
-      Puppet[:confdir] = tmpdir('conf')
-      cert = Puppet::SSL::CertificateAuthority.new.generate('not_my_server', :dns_alt_names => 'foo,bar,baz').content
-
-      connection = Net::HTTP.new('my_server', 8140)
-      @searcher.stubs(:network).returns(connection)
-      ssl_context = OpenSSL::SSL::SSLContext.new
-      ssl_context.stubs(:current_cert).returns(cert)
-      connection.stubs(:get).with do
-        connection.verify_callback.call(true, ssl_context)
-      end.raises(OpenSSL::SSL::SSLError.new('hostname was not match with server certificate'))
-
-      msg = /Server hostname 'my_server' did not match server certificate; expected one of (.+)/
-      expect { @searcher.http_request(:get, stub('request')) }.to(
-        raise_error(Puppet::Error, msg) do |error|
-          error.message =~ msg
+      @searcher.stubs(:network).
+        returns(a_connection_that_verifies(:has_passed_pre_checks => true,
+                                           :in_context => a_store_context(:for_server => 'not_my_server',
+                                                                          :for_aliases => 'foo,bar,baz'),
+                                           :fails_with => 'hostname was not match with server certificate'))
+
+      expect { @searcher.http_request(:get, stub('request')) }.
+        to raise_error(Puppet::Error) do |error|
+          error.message =~ /Server hostname 'my_server' did not match server certificate; expected one of (.+)/
           $1.split(', ').should =~ %w[DNS:foo DNS:bar DNS:baz DNS:not_my_server not_my_server]
         end
-      )
     end
 
     it "should pass along the error message otherwise" do

data/spec/unit/indirector_spec.rb

@@ -37,7 +37,7 @@ describe Puppet::Indirector, "when configuring routes" do
       }
     }
 
-    expect { Puppet::Indirector.configure_routes(routes) }.should raise_error(/fake_indirection does not exist/)
+    expect { Puppet::Indirector.configure_routes(routes) }.to raise_error(/fake_indirection does not exist/)
   end
 
   it "should fail when given an invalid terminus" do
@@ -48,7 +48,7 @@ describe Puppet::Indirector, "when configuring routes" do
       }
     }
 
-    expect { Puppet::Indirector.configure_routes(routes) }.should raise_error(/Could not find terminus fake_terminus/)
+    expect { Puppet::Indirector.configure_routes(routes) }.to raise_error(/Could not find terminus fake_terminus/)
   end
 
   it "should fail when given an invalid cache" do
@@ -59,7 +59,7 @@ describe Puppet::Indirector, "when configuring routes" do
       }
     }
 
-    expect { Puppet::Indirector.configure_routes(routes) }.should raise_error(/Could not find terminus fake_cache/)
+    expect { Puppet::Indirector.configure_routes(routes) }.to raise_error(/Could not find terminus fake_cache/)
   end
 end
 
@@ -87,7 +87,7 @@ describe Puppet::Indirector, "when registering an indirection" do
   end
 
   it "should require a name when registering a model" do
-    Proc.new {@thingie.send(:indirects) }.should raise_error(ArgumentError)
+    expect {@thingie.send(:indirects) }.to raise_error(ArgumentError)
   end
 
   it "should create an indirection instance to manage each indirecting model" do
@@ -98,7 +98,7 @@ describe Puppet::Indirector, "when registering an indirection" do
   it "should not allow a model to register under multiple names" do
     # Keep track of the indirection instance so we can delete it on cleanup
     @indirection = @thingie.indirects :first
-    Proc.new { @thingie.indirects :second }.should raise_error(ArgumentError)
+    expect { @thingie.indirects :second }.to raise_error(ArgumentError)
   end
 
   it "should make the indirection available via an accessor" do

data/spec/unit/interface/action_builder_spec.rb

@@ -23,8 +23,9 @@ describe Puppet::Interface::ActionBuilder do
   end
 
   it "should require a block" do
-    expect { Puppet::Interface::ActionBuilder.build(nil, :foo) }.
-      should raise_error("Action :foo must specify a block")
+    expect {
+      Puppet::Interface::ActionBuilder.build(nil, :foo)
+    }.to raise_error("Action :foo must specify a block")
   end
 
   it "should require an invocation block" do

data/spec/unit/interface/action_manager_spec.rb

@@ -259,7 +259,7 @@ describe Puppet::Interface::ActionManager do
           when_invoked do |options| true end
           default
         }
-      }.should raise_error /cannot both be default/
+      }.to raise_error /cannot both be default/
     end
   end
 

data/spec/unit/interface/action_spec.rb

@@ -6,8 +6,9 @@ describe Puppet::Interface::Action do
   describe "when validating the action name" do
     [nil, '', 'foo bar', '-foobar'].each do |input|
       it "should treat #{input.inspect} as an invalid name" do
-        expect { Puppet::Interface::Action.new(nil, input) }.
-          should raise_error(/is an invalid action name/)
+        expect {
+          Puppet::Interface::Action.new(nil, input)
+        }.to raise_error(/is an invalid action name/)
       end
     end
   end
@@ -261,7 +262,7 @@ describe Puppet::Interface::Action do
           option "--foo"
           action :bar do option "--foo" end
         end
-      }.should raise_error ArgumentError, /Option foo conflicts with existing option foo/i
+      }.to raise_error ArgumentError, /Option foo conflicts with existing option foo/i
     end
 
     it "should fail when a required action option is not provided" do

data/spec/unit/interface/face_collection_spec.rb

@@ -166,7 +166,7 @@ describe Puppet::Interface::FaceCollection do
     faulty.each do |input|
       it "should fail when presented with #{input.inspect} (#{input.class})" do
         expect { subject.underscorize(input) }.
-          should raise_error ArgumentError, /not a valid face name/
+          to raise_error ArgumentError, /not a valid face name/
       end
     end
   end

data/spec/unit/interface/option_spec.rb

@@ -17,27 +17,31 @@ describe Puppet::Interface::Option do
 
     [:foo, 12, nil, {}, []].each do |input|
       it "should fail sensible when given #{input.inspect}" do
-        expect { Puppet::Interface::Option.new(face, input) }.
-          should raise_error ArgumentError, /is not valid for an option argument/
+        expect {
+          Puppet::Interface::Option.new(face, input)
+        }.to raise_error ArgumentError, /is not valid for an option argument/
       end
     end
 
     ["-foo", "-foo=BAR", "-foo BAR"].each do |input|
       it "should fail with a single dash for long option #{input.inspect}" do
-        expect { Puppet::Interface::Option.new(face, input) }.
-          should raise_error ArgumentError, /long options need two dashes \(--\)/
+        expect {
+          Puppet::Interface::Option.new(face, input)
+        }.to raise_error ArgumentError, /long options need two dashes \(--\)/
       end
     end
   end
 
   it "requires a face when created" do
-    expect { Puppet::Interface::Option.new }.
-      should raise_error ArgumentError, /wrong number of arguments/
+    expect {
+      Puppet::Interface::Option.new
+    }.to raise_error ArgumentError, /wrong number of arguments/
   end
 
   it "also requires some declaration arguments when created" do
-    expect { Puppet::Interface::Option.new(face) }.
-      should raise_error ArgumentError, /No option declarations found/
+    expect {
+      Puppet::Interface::Option.new(face)
+    }.to raise_error ArgumentError, /No option declarations found/
   end
 
   it "should infer the name from an optparse string" do
@@ -113,7 +117,7 @@ describe Puppet::Interface::Option do
       its :default do should be_nil end
 
       it "should set a proc as default" do
-        expect { subject.default = proc { 12 } }.should_not raise_error
+        expect { subject.default = proc { 12 } }.to_not raise_error
       end
 
       [1, {}, [], Object.new, "foo"].each do |input|

data/spec/unit/interface_spec.rb

@@ -20,15 +20,15 @@ describe Puppet::Interface do
 
   describe "#[]" do
     it "should fail when no version is requested" do
-      expect { subject[:huzzah] }.should raise_error ArgumentError
+      expect { subject[:huzzah] }.to raise_error ArgumentError
     end
 
     it "should raise an exception when the requested version is unavailable" do
-      expect { subject[:huzzah, '17.0.0'] }.should raise_error, Puppet::Error
+      expect { subject[:huzzah, '17.0.0'] }.to raise_error, Puppet::Error
     end
 
     it "should raise an exception when the requested face doesn't exist" do
-      expect { subject[:burrble_toot, :current] }.should raise_error, Puppet::Error
+      expect { subject[:burrble_toot, :current] }.to raise_error, Puppet::Error
     end
 
     describe "version matching" do
@@ -98,7 +98,7 @@ describe Puppet::Interface do
 
     it "should require a valid version number" do
       expect { subject.new(:bad_version, 'Rasins') }.
-        should raise_error ArgumentError
+        to raise_error ArgumentError
     end
 
     it "should instance-eval any provided block", :'fails_on_ruby_1.9.2' => true do
@@ -159,7 +159,7 @@ describe Puppet::Interface do
           end
           option "--foo"
         end
-      }.should raise_error ArgumentError, /Option foo conflicts with existing option foo on/i
+      }.to raise_error ArgumentError, /Option foo conflicts with existing option foo on/i
     end
 
     it "should work when two actions have the same option" do

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

@@ -0,0 +1,61 @@
+require 'spec_helper'
+require 'puppet/module_tool/applications'
+require 'puppet_spec/modules'
+
+describe Puppet::ModuleTool::Applications::Unpacker, :fails_on_windows => true do
+  include PuppetSpec::Files
+
+  let(:target) { tmpdir("unpacker") }
+
+  context "initialization" do
+    it "should support filename and basic options" do
+      Puppet::ModuleTool::Applications::Unpacker.new("myusername-mytarball-1.0.0.tar.gz", :target_dir => target)
+    end
+
+    it "should raise ArgumentError when filename is invalid" do
+      expect { Puppet::ModuleTool::Applications::Unpacker.new("invalid.tar.gz", :target_dir => target) }.to raise_error(ArgumentError)
+    end
+  end
+
+  context "#run" do
+    let(:cache_base_path) { Pathname.new(tmpdir("unpacker")) }
+    let(:filename) { tmpdir("module") + "/myusername-mytarball-1.0.0.tar.gz" }
+    let(:build_dir) { Pathname.new(tmpdir("build_dir")) }
+    let(:unpacker) do
+      Puppet::ModuleTool::Applications::Unpacker.new(filename, :target_dir => target)
+    end
+
+    before :each do
+      # Mock redhat for most test cases
+      Facter.stubs(:value).with("operatingsystem").returns("Redhat")
+      build_dir.stubs(:mkpath => nil, :rmtree => nil, :children => [])
+      unpacker.stubs(:build_dir).at_least_once.returns(build_dir)
+      FileUtils.stubs(:mv)
+    end
+
+    context "on linux" do
+      it "should attempt to untar file to temporary location using system tar" do
+        Puppet::Util.expects(:execute).with("tar xzf #{filename} -C #{build_dir}").returns(true)
+        unpacker.run
+      end
+    end
+
+    context "on solaris" do
+      before :each do
+        Facter.expects(:value).with("operatingsystem").returns("Solaris")
+      end
+
+      it "should attempt to untar file to temporary location using gnu tar" do
+        Puppet::Util.stubs(:which).with('gtar').returns('/usr/sfw/bin/gtar')
+        Puppet::Util.expects(:execute).with("gtar xzf #{filename} -C #{build_dir}").returns(true)
+        unpacker.run
+      end
+
+      it "should throw exception if gtar is not in the path exists" do
+        Puppet::Util.stubs(:which).with('gtar').returns(nil)
+        expect { unpacker.run }.to raise_error RuntimeError, "Cannot find the command 'gtar'. Make sure GNU tar is installed, and is in your PATH."
+      end
+    end
+  end
+
+end

data/spec/unit/network/handler/fileserver_spec.rb

@@ -50,9 +50,9 @@ describe Puppet::Network::Handler::FileServer do
         config_file = tmpfile('fileserver.conf')
         File.open(config_file, 'w') { |f| f.puts "#{arg} 127.0.0.1/24" }
 
-        expect { 
-          Puppet::Network::Handler::FileServer.new(:Config => config_file) 
-        }.should raise_error(Puppet::Network::Handler::FileServerError, "No mount specified for argument #{arg} 127.0.0.1/24")
+        expect {
+          Puppet::Network::Handler::FileServer.new(:Config => config_file)
+        }.to raise_error(Puppet::Network::Handler::FileServerError, "No mount specified for argument #{arg} 127.0.0.1/24")
       end
     end
   end

data/spec/unit/other/transbucket_spec.rb

@@ -12,7 +12,7 @@ describe Puppet::TransBucket do
 
     resource = nil
     proc { resource = @bucket.to_ral }.should_not raise_error
-    resource.should be_instance_of(Puppet::Type::Component)
+    resource.must be_instance_of(Puppet::Type::Component)
     resource.title.should == "Foo[luke]"
   end
 
@@ -93,7 +93,7 @@ describe Puppet::TransBucket, " when generating a catalog" do
   it "should convert all transportable objects to RAL resources" do
     @catalog = @top.to_catalog
     @users.each do |name|
-      @catalog.vertices.find { |r| r.class.name == :notify and r.title == name }.should be_instance_of(Puppet::Type.type(:notify))
+      @catalog.vertices.find { |r| r.class.name == :notify and r.title == name }.must be_instance_of(Puppet::Type.type(:notify))
     end
   end
 
@@ -105,18 +105,15 @@ describe Puppet::TransBucket, " when generating a catalog" do
   it "should convert all transportable buckets to RAL components" do
     @catalog = @top.to_catalog
     @fakes.each do |name|
-      @catalog.vertices.find { |r| r.class.name == :component and r.title == name }.should be_instance_of(Puppet::Type.type(:component))
+      @catalog.vertices.find { |r| r.class.name == :component and r.title == name }.must be_instance_of(Puppet::Type.type(:component))
     end
   end
 
   it "should add all resources to the graph's resource table" do
     @catalog = @top.to_catalog
-    @catalog.resource("fake[top]").should equal(@top)
-  end
-
-  it "should finalize all resources" do
-    @catalog = @top.to_catalog
-    @catalog.vertices.each do |vertex| vertex.should be_finalized end
+    @fakes.each do |name|
+      @catalog.resource(name).must be
+    end
   end
 
   it "should only call to_ral on each resource once" do

data/spec/unit/parser/ast/resource_spec.rb

@@ -41,6 +41,33 @@ describe Puppet::Parser::AST::Resource do
       result.should be_include("two")
     end
 
+
+    [5, 5.0, true, false, :three, "foo"].each do |title|
+      it "should stringify the title if it is a #{title.class}" do
+        @instance.title.stubs(:safeevaluate).returns title
+
+        result = @resource.evaluate(@scope).map(&:title)
+        result.first.should == title.to_s
+      end
+    end
+
+    [
+     {:a => 1},
+     /noway/i,
+     Puppet::Resource.new(:notify, "something"),
+     Pathname.new("foo"),
+     (1..50),
+     nil,
+    ].each do |title|
+      it "should fail if the title is a #{title.class}" do
+        @instance.title.stubs(:safeevaluate).returns title
+
+        expect do
+          @resource.evaluate(@scope)
+        end.to raise_error(Puppet::ParseError, /Resource title must be a String, not #{title.class}/)
+      end
+    end
+
     it "should create and return one resource objects per title" do
       titles = []
       %w{one two}.each do |title|

data/spec/unit/parser/functions/create_resources_spec.rb

@@ -19,8 +19,8 @@ describe 'function for dynamically creating resources' do
   end
 
   it 'should require two or three arguments' do
-    expect { @scope.function_create_resources(['foo']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (1; must be 2 or 3)')
-    expect { @scope.function_create_resources(['foo', 'bar', 'blah', 'baz']) }.should raise_error(ArgumentError, 'create_resources(): wrong number of arguments (4; must be 2 or 3)')
+    expect { @scope.function_create_resources(['foo']) }.to raise_error(ArgumentError, 'create_resources(): wrong number of arguments (1; must be 2 or 3)')
+    expect { @scope.function_create_resources(['foo', 'bar', 'blah', 'baz']) }.to raise_error(ArgumentError, 'create_resources(): wrong number of arguments (4; must be 2 or 3)')
   end
 
   describe 'when the caller does not supply a name parameter' do
@@ -57,7 +57,7 @@ describe 'function for dynamically creating resources' do
     end
 
     it 'should fail to add non-existing type' do
-      expect { @scope.function_create_resources(['create-resource-foo', {}]) }.should raise_error(ArgumentError, 'could not create resource of unknown type create-resource-foo')
+      expect { @scope.function_create_resources(['create-resource-foo', {}]) }.to raise_error(ArgumentError, 'could not create resource of unknown type create-resource-foo')
     end
 
     it 'should be able to add edges' do
@@ -65,8 +65,8 @@ describe 'function for dynamically creating resources' do
       rg = catalog.to_ral.relationship_graph
       test  = rg.vertices.find { |v| v.title == 'test' }
       foo   = rg.vertices.find { |v| v.title == 'foo' }
-      test.should be
-      foo.should be
+      test.must be
+      foo.must be
       rg.path_between(test,foo).should be
     end
 
@@ -89,7 +89,7 @@ describe 'function for dynamically creating resources' do
     end
 
     it 'should fail if defines are missing params' do
-      expect { 
+      expect {
         compile_to_catalog(<<-MANIFEST)
           define foocreateresource($one) {
             notify { $name: message => $one }
@@ -97,7 +97,7 @@ describe 'function for dynamically creating resources' do
           
           create_resources('foocreateresource', {'blah'=>{}})
         MANIFEST
-      }.should raise_error(Puppet::Error, 'Must pass one to Foocreateresource[blah] at line 1 on node foonode')
+      }.to raise_error(Puppet::Error, 'Must pass one to Foocreateresource[blah] at line 1 on node foonode')
     end
 
     it 'should be able to add multiple defines' do
@@ -127,8 +127,8 @@ describe 'function for dynamically creating resources' do
       rg = catalog.to_ral.relationship_graph
       test = rg.vertices.find { |v| v.title == 'test' }
       blah = rg.vertices.find { |v| v.title == 'blah' }
-      test.should be
-      blah.should be
+      test.must be
+      blah.must be
       rg.path_between(test,blah).should be
       catalog.resource(:notify, "blah")['message'].should == 'two'
     end
@@ -165,7 +165,7 @@ describe 'function for dynamically creating resources' do
         compile_to_catalog(<<-MANIFEST)
           create_resources('class', {'blah'=>{'one'=>'two'}})
         MANIFEST
-      }.should raise_error(Puppet::Error ,'could not find hostclass blah at line 1 on node foonode')
+      }.to raise_error(Puppet::Error ,'could not find hostclass blah at line 1 on node foonode')
     end
 
     it 'should be able to add edges' do
@@ -182,8 +182,8 @@ describe 'function for dynamically creating resources' do
       rg = catalog.to_ral.relationship_graph
       test   = rg.vertices.find { |v| v.title == 'test' }
       tester = rg.vertices.find { |v| v.title == 'tester' }
-      test.should be
-      tester.should be
+      test.must be
+      tester.must be
       rg.path_between(tester,test).should be
     end