puppet 2.7.18 → 2.7.19

data/spec/unit/provider/user/useradd_spec.rb

@@ -88,6 +88,13 @@ describe provider_class do
       @resource.stubs(:managehome?).returns true
       @provider.check_manage_home.must == ["-m"]
     end
+    
+    it "should return an array with -r flag if home is managed" do
+      @resource.stubs(:managehome?).returns true
+      @resource.stubs(:ensure) == :absent
+      @provider.stubs(:command).returns("userdel")
+      @provider.deletecmd.must == ["userdel", "-r", "fakeval"]
+    end
 
     it "should return an array with -M if home is not managed and on Redhat" do
       Facter.stubs(:value).with("operatingsystem").returns("RedHat")

data/spec/unit/reports/store_spec.rb

@@ -45,31 +45,31 @@ describe processor do
       @report.process
     end
 
-    ['..', 'hello/', '/hello', 'he/llo', 'hello/..', '.'].each do |node|
-      it "rejects #{node.inspect}" do
-        @report.host = node
-        expect { @report.process }.to raise_error(ArgumentError, /Invalid node/)
-      end
+    it "rejects invalid hostnames" do
+      @report.host = ".."
+      FileTest.expects(:exists?).never
+      Tempfile.expects(:new).never
+      expect { @report.process }.to raise_error(ArgumentError, /Invalid node/)
     end
+  end
 
-    ['.hello', 'hello.', '..hi', 'hi..'].each do |node|
-      it "accepts #{node.inspect}" do
-        @report.host = node
-        @report.process
-      end
+  describe "::destroy" do
+    it "rejects invalid hostnames" do
+      File.expects(:unlink).never
+      expect { processor.destroy("..") }.to raise_error(ArgumentError, /Invalid node/)
     end
   end
 
-  describe "::destroy" do
+  describe "::validate_host" do
     ['..', 'hello/', '/hello', 'he/llo', 'hello/..', '.'].each do |node|
       it "rejects #{node.inspect}" do
-        expect { processor.destroy(node) }.to raise_error(ArgumentError, /Invalid node/)
+        expect { processor.validate_host(node) }.to raise_error(ArgumentError, /Invalid node/)
       end
     end
 
     ['.hello', 'hello.', '..hi', 'hi..'].each do |node|
       it "accepts #{node.inspect}" do
-        processor.destroy(node)
+        processor.validate_host(node)
       end
     end
   end

data/spec/unit/resource/catalog_spec.rb

@@ -309,7 +309,12 @@ describe Puppet::Resource::Catalog, "when compiling" do
     end
 
     it "should add all resources as RAL instances" do
-      @resources.each { |resource| @catalog.resource(resource.ref).should be_instance_of(Puppet::Type) }
+      @resources.each do |resource|
+        # Warning: a failure here will result in "global resource iteration is
+        # deprecated" being raised, because the rspec rendering to get the
+        # result tries to call `each` on the resource, and that raises.
+        @catalog.resource(resource.ref).must be_a_kind_of(Puppet::Type)
+      end
     end
 
     it "should copy the tag list to the new catalog" do
@@ -416,8 +421,8 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     it "should provide a method to add one or more resources" do
       @catalog.add_resource @one, @two
-      @catalog.resource(@one.ref).should equal(@one)
-      @catalog.resource(@two.ref).should equal(@two)
+      @catalog.resource(@one.ref).must equal(@one)
+      @catalog.resource(@two.ref).must equal(@two)
     end
 
     it "should add resources to the relationship graph if it exists" do
@@ -433,20 +438,18 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     it "should make all vertices available by resource reference" do
       @catalog.add_resource(@one)
-      @catalog.resource(@one.ref).should equal(@one)
-      @catalog.vertices.find { |r| r.ref == @one.ref }.should equal(@one)
+      @catalog.resource(@one.ref).must equal(@one)
+      @catalog.vertices.find { |r| r.ref == @one.ref }.must equal(@one)
     end
 
     it "should canonize how resources are referred to during retrieval when both type and title are provided" do
       @catalog.add_resource(@one)
-
-      @catalog.resource("notify", "one").should equal(@one)
+      @catalog.resource("notify", "one").must equal(@one)
     end
 
     it "should canonize how resources are referred to during retrieval when just the title is provided" do
       @catalog.add_resource(@one)
-
-      @catalog.resource("notify[one]", nil).should equal(@one)
+      @catalog.resource("notify[one]", nil).must equal(@one)
     end
 
     it "should not allow two resources with the same resource reference" do
@@ -502,26 +505,28 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     it "should be able to find resources by reference" do
       @catalog.add_resource @one
-      @catalog.resource(@one.ref).should equal(@one)
+      @catalog.resource(@one.ref).must equal(@one)
     end
 
     it "should be able to find resources by reference or by type/title tuple" do
       @catalog.add_resource @one
-      @catalog.resource("notify", "one").should equal(@one)
+      @catalog.resource("notify", "one").must equal(@one)
     end
 
     it "should have a mechanism for removing resources" do
-      @catalog.add_resource @one
-      @one.expects :remove
+      @catalog.add_resource(@one)
+      @catalog.resource(@one.ref).must be
+      @catalog.vertex?(@one).must be_true
+
       @catalog.remove_resource(@one)
-      @catalog.resource(@one.ref).should be_nil
-      @catalog.vertex?(@one).should be_false
+      @catalog.resource(@one.ref).must be_nil
+      @catalog.vertex?(@one).must be_false
     end
 
     it "should have a method for creating aliases for resources" do
       @catalog.add_resource @one
       @catalog.alias(@one, "other")
-      @catalog.resource("notify", "other").should equal(@one)
+      @catalog.resource("notify", "other").must equal(@one)
     end
 
     it "should ignore conflicting aliases that point to the aliased resource" do
@@ -534,7 +539,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
       @catalog.add_resource(resource)
 
-      @catalog.resource(:file, @basepath+"/something").should equal(resource)
+      @catalog.resource(:file, @basepath+"/something").must equal(resource)
     end
 
     it "should not create aliases for non-isomorphic resources whose names do not match their titles" do
@@ -550,7 +555,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
     it "should alias using the class name from the resource reference, not the resource class name" do
       @catalog.add_resource @one
       @catalog.alias(@one, "other")
-      @catalog.resource("notify", "other").should equal(@one)
+      @catalog.resource("notify", "other").must equal(@one)
     end
 
     it "should fail to add an alias if the aliased name already exists" do
@@ -565,13 +570,13 @@ describe Puppet::Resource::Catalog, "when compiling" do
 
     it "should not create aliases that point back to the resource" do
       @catalog.alias(@one, "one")
-      @catalog.resource(:notify, "one").should be_nil
+      @catalog.resource(:notify, "one").must be_nil
     end
 
     it "should be able to look resources up by their aliases" do
       @catalog.add_resource @one
       @catalog.alias @one, "two"
-      @catalog.resource(:notify, "two").should equal(@one)
+      @catalog.resource(:notify, "two").must equal(@one)
     end
 
     it "should remove resource aliases when the target resource is removed" do
@@ -579,14 +584,14 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog.alias(@one, "other")
       @one.expects :remove
       @catalog.remove_resource(@one)
-      @catalog.resource("notify", "other").should be_nil
+      @catalog.resource("notify", "other").must be_nil
     end
 
     it "should add an alias for the namevar when the title and name differ on isomorphic resource types" do
       resource = Puppet::Type.type(:file).new :path => @basepath+"/something", :title => "other", :content => "blah"
       resource.expects(:isomorphic?).returns(true)
       @catalog.add_resource(resource)
-      @catalog.resource(:file, "other").should equal(resource)
+      @catalog.resource(:file, "other").must equal(resource)
       @catalog.resource(:file, @basepath+"/something").ref.should == resource.ref
     end
 
@@ -594,7 +599,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
       resource = Puppet::Type.type(:file).new :path => @basepath+"/something", :title => "other", :content => "blah"
       resource.expects(:isomorphic?).returns(false)
       @catalog.add_resource(resource)
-      @catalog.resource(:file, resource.title).should equal(resource)
+      @catalog.resource(:file, resource.title).must equal(resource)
       # We can't use .should here, because the resources respond to that method.
       raise "Aliased non-isomorphic resource" if @catalog.resource(:file, resource.name)
     end
@@ -604,7 +609,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
       resource = stub 'file', :ref => "File[/yay]", :catalog= => @catalog, :title => "/yay", :[] => "/yay"
       Puppet::Type.type(:file).expects(:new).with(args).returns(resource)
       @catalog.create_resource :file, args
-      @catalog.resource("File[/yay]").should equal(resource)
+      @catalog.resource("File[/yay]").must equal(resource)
     end
 
     describe "when adding resources with multiple namevars" do

data/spec/unit/resource_spec.rb

@@ -20,7 +20,7 @@ describe Puppet::Resource do
   end
 
   it "should require the type and title" do
-    lambda { Puppet::Resource.new }.should raise_error(ArgumentError)
+    expect { Puppet::Resource.new }.to raise_error(ArgumentError)
   end
 
   it "should canonize types to capitalized strings" do
@@ -93,15 +93,15 @@ describe Puppet::Resource do
 
 
   it "should fail if the title is nil and the type is not a valid resource reference string" do
-    expect { Puppet::Resource.new("resource-spec-foo") }.should raise_error(ArgumentError)
+    expect { Puppet::Resource.new("resource-spec-foo") }.to raise_error(ArgumentError)
   end
 
   it 'should fail if strict is set and type does not exist' do
-    expect { Puppet::Resource.new('resource-spec-foo', 'title', {:strict=>true}) }.should raise_error(ArgumentError, 'Invalid resource type resource-spec-foo')
+    expect { Puppet::Resource.new('resource-spec-foo', 'title', {:strict=>true}) }.to raise_error(ArgumentError, 'Invalid resource type resource-spec-foo')
   end
 
   it 'should fail if strict is set and class does not exist' do
-    expect { Puppet::Resource.new('Class', 'resource-spec-foo', {:strict=>true}) }.should raise_error(ArgumentError, 'Could not find declared class resource-spec-foo')
+    expect { Puppet::Resource.new('Class', 'resource-spec-foo', {:strict=>true}) }.to raise_error(ArgumentError, 'Could not find declared class resource-spec-foo')
   end
 
   it "should fail if the title is a hash and the type is not a valid resource reference string" do
@@ -284,11 +284,11 @@ describe Puppet::Resource do
     end
 
     it "should fail if invalid parameters are used" do
-      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.should raise_error
+      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.to raise_error
     end
 
     it "should fail if the resource type cannot be resolved" do
-      expect { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.should raise_error
+      expect { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.to raise_error
     end
   end
 
@@ -353,7 +353,7 @@ describe Puppet::Resource do
     it "should be able to set the name for non-builtin types" do
       resource = Puppet::Resource.new(:foo, "bar")
       resource[:name] = "eh"
-      expect { resource[:name] = "eh" }.should_not raise_error
+      expect { resource[:name] = "eh" }.to_not raise_error
     end
 
     it "should be able to return the name for non-builtin types" do
@@ -445,7 +445,7 @@ describe Puppet::Resource do
     end
 
     it "should be able to be dumped to yaml" do
-      proc { YAML.dump(@resource) }.should_not raise_error
+      expect { YAML.dump(@resource) }.to_not raise_error
     end
 
     it "should produce an equivalent yaml object" do
@@ -470,7 +470,7 @@ type: File
     end
 
     it "should deserialize a Puppet::Resource::Reference without exceptions" do
-      expect { YAML.load(@old_storedconfig_yaml) }.should_not raise_error
+      expect { YAML.load(@old_storedconfig_yaml) }.to_not raise_error
     end
 
     it "should deserialize as a Puppet::Resource::Reference as a Puppet::Resource" do
@@ -486,7 +486,7 @@ type: File
     it "should use the resource type's :new method to create the resource if the resource is of a builtin type" do
       resource = Puppet::Resource.new("file", basepath+"/my/file")
       result = resource.to_ral
-      result.should be_instance_of(Puppet::Type.type(:file))
+      result.must be_instance_of(Puppet::Type.type(:file))
       result[:path].should == basepath+"/my/file"
     end
 
@@ -494,7 +494,7 @@ type: File
       resource = Puppet::Resource.new("foobar", "somename")
       result = resource.to_ral
 
-      result.should be_instance_of(Puppet::Type.type(:component))
+      result.must be_instance_of(Puppet::Type.type(:component))
       result.title.should == "Foobar[somename]"
     end
   end
@@ -735,12 +735,12 @@ type: File
 
     it "should fail if no title is provided" do
       @data.delete('title')
-      expect { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
+      expect { Puppet::Resource.from_pson(@data) }.to raise_error(ArgumentError)
     end
 
     it "should fail if no type is provided" do
       @data.delete('type')
-      expect { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
+      expect { Puppet::Resource.from_pson(@data) }.to raise_error(ArgumentError)
     end
 
     it "should set each of the provided parameters" do

data/spec/unit/simple_graph_spec.rb

@@ -24,7 +24,7 @@ describe Puppet::SimpleGraph do
     @graph = Puppet::SimpleGraph.new
     @graph.add_edge(:one, :two)
 
-    proc { @graph.to_dot_graph }.should_not raise_error
+    expect { @graph.to_dot_graph }.to_not raise_error
   end
 
   describe "when managing vertices" do
@@ -45,7 +45,7 @@ describe Puppet::SimpleGraph do
 
     it "should ignore already-present vertices when asked to add a vertex" do
       @graph.add_vertex(:test)
-      proc { @graph.add_vertex(:test) }.should_not raise_error
+      expect { @graph.add_vertex(:test) }.to_not raise_error
     end
 
     it "should return true when asked if a vertex is present" do
@@ -72,7 +72,7 @@ describe Puppet::SimpleGraph do
     end
 
     it "should do nothing when a non-vertex is asked to be removed" do
-      proc { @graph.remove_vertex!(:one) }.should_not raise_error
+      expect { @graph.remove_vertex!(:one) }.to_not raise_error
     end
   end
 
@@ -291,22 +291,22 @@ describe Puppet::SimpleGraph do
 
     it "should fail on two-vertex loops" do
       add_edges :a => :b, :b => :a
-      proc { @graph.report_cycles_in_graph }.should raise_error(Puppet::Error)
+      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
     end
 
     it "should fail on multi-vertex loops" do
       add_edges :a => :b, :b => :c, :c => :a
-      proc { @graph.report_cycles_in_graph }.should raise_error(Puppet::Error)
+      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
     end
 
     it "should fail when a larger tree contains a small cycle" do
       add_edges :a => :b, :b => :a, :c => :a, :d => :c
-      proc { @graph.report_cycles_in_graph }.should raise_error(Puppet::Error)
+      expect { @graph.report_cycles_in_graph }.to raise_error(Puppet::Error)
     end
 
     it "should succeed on trees with no cycles" do
       add_edges :a => :b, :b => :e, :c => :a, :d => :c
-      proc { @graph.report_cycles_in_graph }.should_not raise_error
+      expect { @graph.report_cycles_in_graph }.to_not raise_error
     end
 
     it "should produce the correct relationship text" do
@@ -323,7 +323,7 @@ describe Puppet::SimpleGraph do
       add_edges "b" => "c"
 
       cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph }.should_not raise_error
+      expect { cycles = @graph.find_cycles_in_graph }.to_not raise_error
       simplify(cycles).should be == [["a", "b"]]
     end
 
@@ -332,7 +332,7 @@ describe Puppet::SimpleGraph do
       add_edges "b" => "b1", "b1" => "b"
 
       cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph }.should_not raise_error
+      expect { cycles = @graph.find_cycles_in_graph }.to_not raise_error
       simplify(cycles).should be == [["a1", "a"], ["b1", "b"]]
     end
 
@@ -342,7 +342,7 @@ describe Puppet::SimpleGraph do
       add_edges "c" => "c1", "c1" => "c2", "c2" => "c3", "c3" => "c"
 
       cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph }.should_not raise_error
+      expect { cycles = @graph.find_cycles_in_graph }.to_not raise_error
       simplify(cycles).should be == [%w{a1 a}, %w{c1 c2 c3 c}]
     end
 
@@ -353,7 +353,7 @@ describe Puppet::SimpleGraph do
       add_edges "c" => "c2", "c2" => "b"
 
       cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph }.should_not raise_error
+      expect { cycles = @graph.find_cycles_in_graph }.to_not raise_error
       simplify(cycles).should be == [%w{a b c1 c2 c}]
     end
 
@@ -362,7 +362,7 @@ describe Puppet::SimpleGraph do
       (1..(limit - 1)).each do |n| add_edges n.to_s => (n+1).to_s end
 
       cycles = nil
-      expect { cycles = @graph.find_cycles_in_graph }.should_not raise_error
+      expect { cycles = @graph.find_cycles_in_graph }.to_not raise_error
       simplify(cycles).should be == []
     end
 

data/spec/unit/ssl/certificate_authority/interface_spec.rb

@@ -1,4 +1,4 @@
-#!/usr/bin/env rspec
+#!/usr/bin/env ruby -S rspec
 require 'spec_helper'
 
 require 'puppet/ssl/certificate_authority'
@@ -95,14 +95,14 @@ describe Puppet::SSL::CertificateAuthority::Interface do
       lambda { @applier.apply(@ca) }.should raise_error(Puppet::SSL::CertificateAuthority::Interface::InterfaceError)
     end
 
-    it "should log non-Interface failures rather than failing" do
+    it "should log non-Interface failures" do
       @applier = @class.new(:revoke, :to => :all)
 
       @ca.expects(:list).raises ArgumentError
 
       Puppet.expects(:err)
 
-      lambda { @applier.apply(@ca) }.should_not raise_error
+      lambda { @applier.apply(@ca) }.should raise_error
     end
 
     describe "with an empty array specified and the method is not list" do

data/spec/unit/ssl/certificate_authority_spec.rb

@@ -370,14 +370,15 @@ describe Puppet::SSL::CertificateAuthority do
       it "should fail if no CSR can be found for the host" do
         Puppet::SSL::CertificateRequest.indirection.expects(:find).with(@name).returns nil
 
-        lambda { @ca.sign(@name) }.should raise_error(ArgumentError)
+        expect { @ca.sign(@name) }.to raise_error(ArgumentError)
       end
 
       it "should fail if an unknown request extension is present" do
         @request.stubs :request_extensions => [{ "oid"   => "bananas",
                                                  "value" => "delicious" }]
-        expect { @ca.sign(@name) }.
-          should raise_error(/CSR has request extensions that are not permitted/)
+        expect {
+          @ca.sign(@name)
+        }.to raise_error(/CSR has request extensions that are not permitted/)
       end
 
       it "should fail if the CSR contains alt names and they are not expected" do
@@ -390,7 +391,7 @@ describe Puppet::SSL::CertificateAuthority do
 
       it "should not fail if the CSR does not contain alt names and they are expected" do
         @request.stubs(:subject_alt_names).returns []
-        expect { @ca.sign(@name, true) }.should_not raise_error
+        expect { @ca.sign(@name, true) }.to_not raise_error
       end
 
       it "should reject alt names by default" do
@@ -705,7 +706,7 @@ describe Puppet::SSL::CertificateAuthority do
 
     describe "when applying a method to a set of hosts" do
       it "should fail if no subjects have been specified" do
-        lambda { @ca.apply(:generate) }.should raise_error(ArgumentError)
+        expect { @ca.apply(:generate) }.to raise_error(ArgumentError)
       end
 
       it "should create an Interface instance with the specified method and the options" do
@@ -769,7 +770,7 @@ describe Puppet::SSL::CertificateAuthority do
       it "should raise an error if the certificate or CSR cannot be found" do
         Puppet::SSL::Certificate.indirection.expects(:find).with("myhost").returns nil
         Puppet::SSL::CertificateRequest.indirection.expects(:find).with("myhost").returns nil
-        lambda { @ca.fingerprint("myhost") }.should raise_error
+        expect { @ca.fingerprint("myhost") }.to raise_error
       end
 
       it "should try to find a CSR if no certificate can be found" do
@@ -809,7 +810,7 @@ describe Puppet::SSL::CertificateAuthority do
       it "should fail if the host's certificate cannot be found" do
         Puppet::SSL::Certificate.indirection.expects(:find).with("me").returns(nil)
 
-        lambda { @ca.verify("me") }.should raise_error(ArgumentError)
+        expect { @ca.verify("me") }.to raise_error(ArgumentError)
       end
 
       it "should create an SSL Store to verify" do
@@ -857,7 +858,7 @@ describe Puppet::SSL::CertificateAuthority do
 
         @store.expects(:verify).with("mycert").returns false
 
-        lambda { @ca.verify("me") }.should raise_error
+        expect { @ca.verify("me") }.to raise_error
       end
     end
 
@@ -877,7 +878,7 @@ describe Puppet::SSL::CertificateAuthority do
       it "should fail if the certificate revocation list is disabled" do
         @ca.stubs(:crl).returns false
 
-        lambda { @ca.revoke('ca_testing') }.should raise_error(ArgumentError)
+        expect { @ca.revoke('ca_testing') }.to raise_error(ArgumentError)
 
       end
 
@@ -923,7 +924,7 @@ describe Puppet::SSL::CertificateAuthority do
       it "should fail if a certificate already exists for the host" do
         Puppet::SSL::Certificate.indirection.expects(:find).with("him").returns "something"
 
-        lambda { @ca.generate("him") }.should raise_error(ArgumentError)
+        expect { @ca.generate("him") }.to raise_error(ArgumentError)
       end
 
       it "should create a new Host instance with the correct name" do