puppet 2.7.5 → 2.7.6

data/spec/unit/indirector/certificate_request/ca_spec.rb

@@ -2,8 +2,6 @@
 require 'spec_helper'
 
 require 'puppet/ssl/host'
-require 'puppet/sslcertificates'
-require 'puppet/sslcertificates/ca'
 require 'puppet/indirector/certificate_request/ca'
 
 describe Puppet::SSL::CertificateRequest::Ca, :unless => Puppet.features.microsoft_windows? do
@@ -14,7 +12,6 @@ describe Puppet::SSL::CertificateRequest::Ca, :unless => Puppet.features.microso
 
     Puppet::SSL::Host.ca_location = :local
     Puppet[:localcacert] = Puppet[:cacert]
-    Puppet::SSLCertificates::CA.new.mkrootcert
 
     @ca = Puppet::SSL::CertificateAuthority.new
   end

data/spec/unit/indirector/direct_file_server_spec.rb

@@ -17,7 +17,8 @@ describe Puppet::Indirector::DirectFileServer do
 
     @server = @direct_file_class.new
 
-    @uri = "file:///my/local"
+    @path = File.expand_path('/my/local')
+    @uri = Puppet::Util.path_to_uri(@path).to_s
 
     @request = Puppet::Indirector::Request.new(:mytype, :find, @uri)
   end
@@ -25,12 +26,12 @@ describe Puppet::Indirector::DirectFileServer do
   describe Puppet::Indirector::DirectFileServer, "when finding a single file" do
 
     it "should return nil if the file does not exist" do
-      FileTest.expects(:exists?).with("/my/local").returns false
+      FileTest.expects(:exists?).with(@path).returns false
       @server.find(@request).should be_nil
     end
 
     it "should return a Content instance created with the full path to the file if the file exists" do
-      FileTest.expects(:exists?).with("/my/local").returns true
+      FileTest.expects(:exists?).with(@path).returns true
       @model.expects(:new).returns(:mycontent)
       @server.find(@request).should == :mycontent
     end
@@ -41,11 +42,11 @@ describe Puppet::Indirector::DirectFileServer do
     before do
       @data = mock 'content'
       @data.stubs(:collect)
-      FileTest.expects(:exists?).with("/my/local").returns true
+      FileTest.expects(:exists?).with(@path).returns true
     end
 
     it "should pass the full path to the instance" do
-      @model.expects(:new).with { |key, options| key == "/my/local" }.returns(@data)
+      @model.expects(:new).with { |key, options| key == @path }.returns(@data)
       @server.find(@request)
     end
 
@@ -60,19 +61,19 @@ describe Puppet::Indirector::DirectFileServer do
 
   describe Puppet::Indirector::DirectFileServer, "when searching for multiple files" do
     it "should return nil if the file does not exist" do
-      FileTest.expects(:exists?).with("/my/local").returns false
+      FileTest.expects(:exists?).with(@path).returns false
       @server.find(@request).should be_nil
     end
 
     it "should use :path2instances from the terminus_helper to return instances if the file exists" do
-      FileTest.expects(:exists?).with("/my/local").returns true
+      FileTest.expects(:exists?).with(@path).returns true
       @server.expects(:path2instances)
       @server.search(@request)
     end
 
     it "should pass the original request to :path2instances" do
-      FileTest.expects(:exists?).with("/my/local").returns true
-      @server.expects(:path2instances).with(@request, "/my/local")
+      FileTest.expects(:exists?).with(@path).returns true
+      @server.expects(:path2instances).with(@request, @path)
       @server.search(@request)
     end
   end

data/spec/unit/indirector/file_metadata/file_spec.rb

@@ -15,10 +15,11 @@ describe Puppet::Indirector::FileMetadata::File do
   describe "when creating the instance for a single found file" do
     before do
       @metadata = Puppet::Indirector::FileMetadata::File.new
-      @uri = "file:///my/local"
+      @path = File.expand_path('/my/local')
+      @uri = Puppet::Util.path_to_uri(@path).to_s
       @data = mock 'metadata'
       @data.stubs(:collect)
-      FileTest.expects(:exists?).with("/my/local").returns true
+      FileTest.expects(:exists?).with(@path).returns true
 
       @request = Puppet::Indirector::Request.new(:file_metadata, :find, @uri)
     end
@@ -34,13 +35,14 @@ describe Puppet::Indirector::FileMetadata::File do
   describe "when searching for multiple files" do
     before do
       @metadata = Puppet::Indirector::FileMetadata::File.new
-      @uri = "file:///my/local"
+      @path = File.expand_path('/my/local')
+      @uri = Puppet::Util.path_to_uri(@path).to_s
 
       @request = Puppet::Indirector::Request.new(:file_metadata, :find, @uri)
     end
 
     it "should collect the attributes of the instances returned" do
-      FileTest.expects(:exists?).with("/my/local").returns true
+      FileTest.expects(:exists?).with(@path).returns true
       @metadata.expects(:path2instances).returns( [mock("one", :collect => nil), mock("two", :collect => nil)] )
       @metadata.search(@request)
     end

data/spec/unit/indirector/request_spec.rb

@@ -85,13 +85,15 @@ describe Puppet::Indirector::Request do
     end
 
     describe "and the request key is a URI" do
+      let(:file) { File.expand_path("/my/file with spaces") }
+
       describe "and the URI is a 'file' URI" do
         before do
-          @request = Puppet::Indirector::Request.new(:ind, :method, "file:///my/file with spaces")
+          @request = Puppet::Indirector::Request.new(:ind, :method, "#{URI.unescape(Puppet::Util.path_to_uri(file).to_s)}")
         end
 
         it "should set the request key to the unescaped full file path" do
-          @request.key.should == "/my/file with spaces"
+          @request.key.should == file
         end
 
         it "should not set the protocol" do
@@ -133,7 +135,15 @@ describe Puppet::Indirector::Request do
       end
 
       it "should set the :uri attribute to the full URI" do
-        Puppet::Indirector::Request.new(:ind, :method, "http:///stuff").uri.should == "http:///stuff"
+        Puppet::Indirector::Request.new(:ind, :method, "http:///stu ff").uri.should == 'http:///stu ff'
+      end
+
+      it "should not parse relative URI" do
+        Puppet::Indirector::Request.new(:ind, :method, "foo/bar").uri.should be_nil
+      end
+
+      it "should not parse opaque URI" do
+        Puppet::Indirector::Request.new(:ind, :method, "mailto:joe").uri.should be_nil
       end
     end
 

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

@@ -48,19 +48,15 @@ describe "Puppet::Resource::ActiveRecord", :if => (Puppet.features.rails? and de
       subject.search(Puppet::Resource.indirection.request(:search, type, args))
     end
 
-    it "should fail if the type is not known to Puppet" do
-      expect { search("banana") }.to raise_error Puppet::Error, /Could not find type/
-    end
-
     it "should return an empty array if no resources match" do
-      search("exec").should == []
+      search("Exec").should == []
     end
 
     # Assert that this is a case-insensitive rule, too.
     %w{and or AND OR And Or anD oR}.each do |op|
       it "should fail if asked to search with #{op.inspect}" do
         filter = [%w{tag == foo}, op, %w{title == bar}]
-        expect { search("notify", 'localhost', filter) }.
+        expect { search("Notify", 'localhost', filter) }.
           to raise_error Puppet::Error, /not supported/
       end
     end
@@ -76,7 +72,7 @@ describe "Puppet::Resource::ActiveRecord", :if => (Puppet.features.rails? and de
       end
 
       it "should return something responding to `to_resource` if a resource matches" do
-        found = search("exec")
+        found = search("Exec")
         found.length.should == 1
         found.map do |item|
           item.should respond_to :to_resource
@@ -95,9 +91,7 @@ describe "Puppet::Resource::ActiveRecord", :if => (Puppet.features.rails? and de
       Puppet::Rails.init
     end
 
-    let :type do
-      Puppet::Type.type('notify').name
-    end
+    let :type do 'Notify' end
 
     def query(type, host, filter = nil)
       subject.send :build_active_record_query, type, host, filter

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

@@ -108,21 +108,23 @@ describe "Puppet::Resource::Ral" do
       @instance    = stub 'instance', :to_ral => @ral_res
       @request     = stub 'request',  :key => "user/", :instance => @instance
       @catalog     = stub 'catalog'
+      @report      = stub 'report'
+      @transaction = stub 'transaction', :report => @report
 
       Puppet::Resource::Catalog.stubs(:new).returns(@catalog)
-      @catalog.stubs(:apply)
+      @catalog.stubs(:apply).returns(@transaction)
       @catalog.stubs(:add_resource)
     end
 
     it "should apply a new catalog with a ral object in it" do
       Puppet::Resource::Catalog.expects(:new).returns(@catalog)
       @catalog.expects(:add_resource).with(@ral_res)
-      @catalog.expects(:apply)
-      Puppet::Resource::Ral.new.save(@request)
+      @catalog.expects(:apply).returns(@transaction)
+      Puppet::Resource::Ral.new.save(@request).should
     end
 
     it "should return a regular resource that used to be the ral resource" do
-      Puppet::Resource::Ral.new.save(@request).should == @rebuilt_res
+      Puppet::Resource::Ral.new.save(@request).should == [@rebuilt_res, @report]
     end
   end
 end

data/spec/unit/indirector/rest_spec.rb

@@ -91,6 +91,8 @@ describe Puppet::Indirector::REST do
   end
 
   describe "when making http requests" do
+    include PuppetSpec::Files
+
     it "should provide a suggestive error message when certificate verify failed" do
       connection = Net::HTTP.new('my_server', 8140)
       @searcher.stubs(:network).returns(connection)
@@ -103,11 +105,8 @@ describe Puppet::Indirector::REST do
     end
 
     it "should provide a helpful error message when hostname was not match with server certificate" do
-      Puppet[:certdnsnames] = 'foo:bar:baz'
-      csr            = OpenSSL::X509::Request.new
-      csr.subject    = OpenSSL::X509::Name.new([['CN', 'not_my_server']])
-      csr.public_key = OpenSSL::PKey::RSA.generate(Puppet[:keylength]).public_key
-      cert = Puppet::SSL::CertificateFactory.new('server', csr, csr, 14).result
+      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)
@@ -121,7 +120,7 @@ describe Puppet::Indirector::REST do
       expect { @searcher.http_request(:get, stub('request')) }.to(
         raise_error(Puppet::Error, msg) do |error|
           error.message =~ msg
-          $1.split(', ').should =~ ['foo', 'bar', 'baz', 'not_my_server']
+          $1.split(', ').should =~ %w[DNS:foo DNS:bar DNS:baz DNS:not_my_server not_my_server]
         end
       )
     end

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

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+require 'puppet/network/handler/ca'
+
+describe Puppet::Network::Handler::CA do
+  include PuppetSpec::Files
+
+  describe "#getcert" do
+    let(:host)      { "testhost" }
+    let(:x509_name) { OpenSSL::X509::Name.new [['CN', host]] }
+    let(:key)       { Puppet::SSL::Key.new(host).generate }
+
+    let(:csr) do
+      csr = OpenSSL::X509::Request.new
+      csr.subject = x509_name
+      csr.public_key = key.public_key
+      csr
+    end
+
+    let(:ca)     { Puppet::SSL::CertificateAuthority.new }
+    let(:cacert) { ca.instance_variable_get(:@certificate) }
+
+    before :each do
+      Puppet[:confdir] = tmpdir('conf')
+
+      Puppet::SSL::CertificateAuthority.stubs(:ca?).returns true
+      Puppet::SSL::CertificateAuthority.stubs(:singleton_instance).returns ca
+    end
+
+    it "should do nothing if the master is not a CA" do
+      Puppet::SSL::CertificateAuthority.stubs(:ca?).returns false
+
+      csr = OpenSSL::X509::Request.new
+      subject.getcert(csr.to_pem).should == ''
+    end
+
+    describe "when a certificate already exists for the host" do
+      let!(:cert)    { ca.generate(host) }
+
+      it "should return the existing cert if it matches the public key of the CSR" do
+        csr.public_key = cert.content.public_key
+
+        subject.getcert(csr.to_pem).should == [cert.to_s, cacert.to_s]
+      end
+
+      it "should fail if the public key of the CSR does not match the existing cert" do
+        expect do
+          subject.getcert(csr.to_pem)
+        end.to raise_error(Puppet::Error, /Certificate request does not match existing certificate/)
+      end
+    end
+
+    describe "when autosign is enabled" do
+      before :each do
+        Puppet[:autosign] = true
+      end
+
+      it "should return the new cert and the CA cert" do
+        cert_str, cacert_str = subject.getcert(csr.to_pem)
+
+        returned_cert = Puppet::SSL::Certificate.from_s(cert_str)
+        returned_cacert = Puppet::SSL::Certificate.from_s(cacert_str)
+
+        returned_cert.name.should == host
+        returned_cacert.content.subject.cmp(cacert.content.subject).should == 0
+      end
+    end
+
+    describe "when autosign is disabled" do
+      before :each do
+        Puppet[:autosign] = false
+      end
+
+      it "should save the CSR without signing it" do
+        subject.getcert(csr.to_pem)
+
+        Puppet::SSL::Certificate.indirection.find(host).should be_nil
+        Puppet::SSL::CertificateRequest.indirection.find(host).should be_a(Puppet::SSL::CertificateRequest)
+      end
+
+      it "should not return a cert" do
+        subject.getcert(csr.to_pem).should be_nil
+      end
+    end
+  end
+end

data/spec/unit/parser/collector_spec.rb

@@ -340,7 +340,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
-                :restype  => 'notify', :title => 'whammo',
+                :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       result = @collector.evaluate
@@ -354,7 +354,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
-                :restype  => 'notify', :title => 'whammo',
+                :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       param = Puppet::Parser::Resource::Param.
@@ -369,7 +369,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
-                :restype  => 'notify', :title => 'whammo',
+                :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       @compiler.expects(:add_resource).with do |scope, resource|
@@ -387,7 +387,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
-                :restype  => 'notify', :title => 'whammo',
+                :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       got = @collector.evaluate
@@ -401,7 +401,7 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       host = Puppet::Rails::Host.create!(:name => 'one.local')
       Puppet::Rails::Resource.
         create!(:host     => host,
-                :restype  => 'notify', :title => 'whammo',
+                :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
 
       local = Puppet::Parser::Resource.new('notify', 'whammo', :scope => @scope)
@@ -416,12 +416,12 @@ describe Puppet::Parser::Collector, "when collecting exported resources", :if =>
       # One that we already collected...
       db = Puppet::Rails::Resource.
         create!(:host     => host,
-                :restype  => 'notify', :title => 'whammo',
+                :restype  => 'Notify', :title => 'whammo',
                 :exported => true)
       # ...and one we didn't.
       Puppet::Rails::Resource.
         create!(:host     => host,
-                :restype  => 'notify', :title => 'boingy-boingy',
+                :restype  => 'Notify', :title => 'boingy-boingy',
                 :exported => true)
 
       local = Puppet::Parser::Resource.new('notify', 'whammo',

data/spec/unit/parser/scope_spec.rb

@@ -52,6 +52,26 @@ describe Puppet::Parser::Scope do
     Puppet::Parser::Scope.ancestors.should include(Puppet::Resource::TypeCollectionHelper)
   end
 
+  describe "when missing methods are called" do
+    before :each do
+      @env      = Puppet::Node::Environment.new('testing')
+      @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new('foo', :environment => @env))
+      @scope    = Puppet::Parser::Scope.new(:compiler => @compiler)
+    end
+
+    it "should load and call the method if it looks like a function and it exists" do
+      @scope.function_sprintf(["%b", 123]).should == "1111011"
+    end
+
+    it "should raise NoMethodError if the method doesn't look like a function" do
+      expect { @scope.sprintf(["%b", 123]) }.should raise_error(NoMethodError)
+    end
+
+    it "should raise NoMethodError if the method looks like a function but doesn't exist" do
+      expect { @scope.function_fake_bs(['cows']) }.should raise_error(NoMethodError)
+    end
+  end
+
   describe "when initializing" do
     it "should extend itself with its environment's Functions module as well as the default" do
       env = Puppet::Node::Environment.new("myenv")

data/spec/unit/provider/file/posix_spec.rb

@@ -0,0 +1,226 @@
+#!/usr/bin/env rspec
+
+require 'spec_helper'
+
+describe Puppet::Type.type(:file).provider(:posix), :if => Puppet.features.posix? do
+  include PuppetSpec::Files
+
+  let(:path) { tmpfile('posix_file_spec') }
+  let(:resource) { Puppet::Type.type(:file).new :path => path, :mode => 0777, :provider => described_class.name }
+  let(:provider) { resource.provider }
+
+  describe "#mode" do
+    it "should return a string with the higher-order bits stripped away" do
+      FileUtils.touch(path)
+      File.chmod(0644, path)
+
+      provider.mode.should == '644'
+    end
+
+    it "should return absent if the file doesn't exist" do
+      provider.mode.should == :absent
+    end
+  end
+
+  describe "#mode=" do
+    it "should chmod the file to the specified value" do
+      FileUtils.touch(path)
+      File.chmod(0644, path)
+
+      provider.mode = '0755'
+
+      provider.mode.should == '755'
+    end
+
+    it "should pass along any errors encountered" do
+      expect do
+        provider.mode = '644'
+      end.to raise_error(Puppet::Error, /failed to set mode/)
+    end
+  end
+
+  describe "#uid2name" do
+    it "should return the name of the user identified by the id" do
+      Etc.stubs(:getpwuid).with(501).returns(Struct::Passwd.new('jilluser', nil, 501))
+
+      provider.uid2name(501).should == 'jilluser'
+    end
+
+    it "should return the argument if it's already a name" do
+      provider.uid2name('jilluser').should == 'jilluser'
+    end
+
+    it "should return nil if the argument is above the maximum uid" do
+      provider.uid2name(Puppet[:maximum_uid] + 1).should == nil
+    end
+
+    it "should return nil if the user doesn't exist" do
+      Etc.expects(:getpwuid).raises(ArgumentError, "can't find user for 999")
+
+      provider.uid2name(999).should == nil
+    end
+  end
+
+  describe "#name2uid" do
+    it "should return the id of the user if it exists" do
+      passwd = Struct::Passwd.new('bobbo', nil, 502)
+
+      Etc.stubs(:getpwnam).with('bobbo').returns(passwd)
+      Etc.stubs(:getpwuid).with(502).returns(passwd)
+
+      provider.name2uid('bobbo').should == 502
+    end
+
+    it "should return the argument if it's already an id" do
+      provider.name2uid('503').should == 503
+    end
+
+    it "should return false if the user doesn't exist" do
+      Etc.stubs(:getpwnam).with('chuck').raises(ArgumentError, "can't find user for chuck")
+
+      provider.name2uid('chuck').should == false
+    end
+  end
+
+  describe "#owner" do
+    it "should return the uid of the file owner" do
+      FileUtils.touch(path)
+      owner = File.stat(path).uid
+
+      provider.owner.should == owner
+    end
+
+    it "should return absent if the file can't be statted" do
+      provider.owner.should == :absent
+    end
+
+    it "should warn and return :silly if the value is beyond the maximum uid" do
+      stat = stub('stat', :uid => Puppet[:maximum_uid] + 1)
+      resource.stubs(:stat).returns(stat)
+
+      provider.owner.should == :silly
+      @logs.should be_any {|log| log.level == :warning and log.message =~ /Apparently using negative UID/}
+    end
+  end
+
+  describe "#owner=" do
+    it "should set the owner but not the group of the file" do
+      File.expects(:lchown).with(15, nil, resource[:path])
+
+      provider.owner = 15
+    end
+
+    it "should chown a link if managing links" do
+      resource[:links] = :manage
+      File.expects(:lchown).with(20, nil, resource[:path])
+
+      provider.owner = 20
+    end
+
+    it "should chown a link target if following links" do
+      resource[:links] = :follow
+      File.expects(:chown).with(20, nil, resource[:path])
+
+      provider.owner = 20
+    end
+
+    it "should pass along any error encountered setting the owner" do
+      File.expects(:lchown).raises(ArgumentError)
+
+      expect { provider.owner = 25 }.to raise_error(Puppet::Error, /Failed to set owner to '25'/)
+    end
+  end
+
+  describe "#gid2name" do
+    it "should return the name of the group identified by the id" do
+      Etc.stubs(:getgrgid).with(501).returns(Struct::Passwd.new('unicorns', nil, nil, 501))
+
+      provider.gid2name(501).should == 'unicorns'
+    end
+
+    it "should return the argument if it's already a name" do
+      provider.gid2name('leprechauns').should == 'leprechauns'
+    end
+
+    it "should return nil if the argument is above the maximum gid" do
+      provider.gid2name(Puppet[:maximum_uid] + 1).should == nil
+    end
+
+    it "should return nil if the group doesn't exist" do
+      Etc.expects(:getgrgid).raises(ArgumentError, "can't find group for 999")
+
+      provider.gid2name(999).should == nil
+    end
+  end
+
+  describe "#name2gid" do
+    it "should return the id of the group if it exists" do
+      passwd = Struct::Passwd.new('penguins', nil, nil, 502)
+
+      Etc.stubs(:getgrnam).with('penguins').returns(passwd)
+      Etc.stubs(:getgrgid).with(502).returns(passwd)
+
+      provider.name2gid('penguins').should == 502
+    end
+
+    it "should return the argument if it's already an id" do
+      provider.name2gid('503').should == 503
+    end
+
+    it "should return false if the group doesn't exist" do
+      Etc.stubs(:getgrnam).with('wombats').raises(ArgumentError, "can't find group for wombats")
+
+      provider.name2gid('wombats').should == false
+    end
+
+  end
+
+  describe "#group" do
+    it "should return the gid of the file group" do
+      FileUtils.touch(path)
+      group = File.stat(path).gid
+
+      provider.group.should == group
+    end
+
+    it "should return absent if the file can't be statted" do
+      provider.group.should == :absent
+    end
+
+    it "should warn and return :silly if the value is beyond the maximum gid" do
+      stat = stub('stat', :gid => Puppet[:maximum_uid] + 1)
+      resource.stubs(:stat).returns(stat)
+
+      provider.group.should == :silly
+      @logs.should be_any {|log| log.level == :warning and log.message =~ /Apparently using negative GID/}
+    end
+  end
+
+  describe "#group=" do
+    it "should set the group but not the owner of the file" do
+      File.expects(:lchown).with(nil, 15, resource[:path])
+
+      provider.group = 15
+    end
+
+    it "should change the group for a link if managing links" do
+      resource[:links] = :manage
+      File.expects(:lchown).with(nil, 20, resource[:path])
+
+      provider.group = 20
+    end
+
+    it "should change the group for a link target if following links" do
+      resource[:links] = :follow
+      File.expects(:chown).with(nil, 20, resource[:path])
+
+      provider.group = 20
+    end
+
+    it "should pass along any error encountered setting the group" do
+      File.expects(:lchown).raises(ArgumentError)
+
+      expect { provider.group = 25 }.to raise_error(Puppet::Error, /Failed to set group to '25'/)
+    end
+  end
+end