puppet 2.7.5 → 2.7.6

data/spec/shared_behaviours/file_serving.rb

@@ -43,13 +43,14 @@ shared_examples_for "Puppet::FileServing::Files" do
   end
 
   it "should use the file terminus when the 'file' URI scheme is used" do
-    uri = "file:///fakemod/my/file"
+    uri = Puppet::Util.path_to_uri(File.expand_path('/fakemod/my/other file'))
+    uri.scheme.should == 'file'
     @indirection.terminus(:file).expects(:find)
-    @indirection.find(uri)
+    @indirection.find(uri.to_s)
   end
 
   it "should use the file terminus when a fully qualified path is provided" do
-    uri = "/fakemod/my/file"
+    uri = File.expand_path("/fakemod/my/file")
     @indirection.terminus(:file).expects(:find)
     @indirection.find(uri)
   end

data/spec/unit/application/agent_spec.rb

@@ -367,6 +367,7 @@ describe Puppet::Application::Agent do
     end
 
     it "should daemonize if needed" do
+      Puppet.features.stubs(:microsoft_windows?).returns false
       Puppet[:daemonize] = true
 
       @daemon.expects(:daemonize)

data/spec/unit/application/device_spec.rb

@@ -338,6 +338,11 @@ describe Puppet::Application::Device do
         @device.main
       end
 
+      it "should expire all cached attributes" do
+        Puppet::SSL::Host.expects(:reset).twice
+
+        @device.main
+      end
     end
   end
 end

data/spec/unit/application/resource_spec.rb

@@ -5,71 +5,38 @@ require 'puppet/application/resource'
 
 describe Puppet::Application::Resource do
   before :each do
-    @resource = Puppet::Application[:resource]
+    @resource_app = Puppet::Application[:resource]
     Puppet::Util::Log.stubs(:newdestination)
     Puppet::Resource.indirection.stubs(:terminus_class=)
   end
 
   it "should ask Puppet::Application to not parse Puppet configuration file" do
-    @resource.should_parse_config?.should be_false
-  end
-
-  it "should declare a main command" do
-    @resource.should respond_to(:main)
-  end
-
-  it "should declare a host option" do
-    @resource.should respond_to(:handle_host)
-  end
-
-  it "should declare a types option" do
-    @resource.should respond_to(:handle_types)
-  end
-
-  it "should declare a param option" do
-    @resource.should respond_to(:handle_param)
-  end
-
-  it "should declare a preinit block" do
-    @resource.should respond_to(:preinit)
+    @resource_app.should_parse_config?.should be_false
   end
 
   describe "in preinit" do
-    it "should set hosts to nil", :'fails_on_ruby_1.9.2' => true do
-      @resource.preinit
-
-      @resource.host.should be_nil
-    end
-
     it "should init extra_params to empty array", :'fails_on_ruby_1.9.2' => true do
-      @resource.preinit
-
-      @resource.extra_params.should == []
+      @resource_app.preinit
+      @resource_app.extra_params.should == []
     end
 
     it "should load Facter facts" do
       Facter.expects(:loadfacts).once
-      @resource.preinit
+      @resource_app.preinit
     end
   end
 
   describe "when handling options" do
-
     [:debug, :verbose, :edit].each do |option|
-      it "should declare handle_#{option} method" do
-        @resource.should respond_to("handle_#{option}".to_sym)
-      end
-
       it "should store argument value when calling handle_#{option}" do
-        @resource.options.expects(:[]=).with(option, 'arg')
-        @resource.send("handle_#{option}".to_sym, 'arg')
+        @resource_app.options.expects(:[]=).with(option, 'arg')
+        @resource_app.send("handle_#{option}".to_sym, 'arg')
       end
     end
 
     it "should set options[:host] to given host" do
-      @resource.handle_host(:whatever)
-
-      @resource.host.should == :whatever
+      @resource_app.handle_host(:whatever)
+      @resource_app.host.should == :whatever
     end
 
     it "should load an display all types with types option" do
@@ -77,15 +44,15 @@ describe Puppet::Application::Resource do
       type2 = stub_everything 'type2', :name => :type2
       Puppet::Type.stubs(:loadall)
       Puppet::Type.stubs(:eachtype).multiple_yields(type1,type2)
-      @resource.expects(:puts).with(['type1','type2'])
-      expect { @resource.handle_types(nil) }.to exit_with 0
+      @resource_app.expects(:puts).with(['type1','type2'])
+      expect { @resource_app.handle_types(nil) }.to exit_with 0
     end
 
     it "should add param to extra_params list" do
-      @resource.extra_params = [ :param1 ]
-      @resource.handle_param("whatever")
+      @resource_app.extra_params = [ :param1 ]
+      @resource_app.handle_param("whatever")
 
-      @resource.extra_params.should == [ :param1, :whatever ]
+      @resource_app.extra_params.should == [ :param1, :whatever ]
     end
   end
 
@@ -95,63 +62,65 @@ describe Puppet::Application::Resource do
       Puppet.stubs(:parse_config)
     end
 
-
     it "should set console as the log destination" do
       Puppet::Log.expects(:newdestination).with(:console)
 
-      @resource.setup
+      @resource_app.setup
     end
 
     it "should set log level to debug if --debug was passed" do
-      @resource.options.stubs(:[]).with(:debug).returns(true)
-      @resource.setup
+      @resource_app.options.stubs(:[]).with(:debug).returns(true)
+      @resource_app.setup
       Puppet::Log.level.should == :debug
     end
 
     it "should set log level to info if --verbose was passed" do
-      @resource.options.stubs(:[]).with(:debug).returns(false)
-      @resource.options.stubs(:[]).with(:verbose).returns(true)
-      @resource.setup
+      @resource_app.options.stubs(:[]).with(:debug).returns(false)
+      @resource_app.options.stubs(:[]).with(:verbose).returns(true)
+      @resource_app.setup
       Puppet::Log.level.should == :info
     end
 
     it "should Parse puppet config" do
       Puppet.expects(:parse_config)
 
-      @resource.setup
+      @resource_app.setup
     end
   end
 
   describe "when running" do
-
     before :each do
       @type = stub_everything 'type', :properties => []
-      @resource.command_line.stubs(:args).returns(['type'])
+      @resource_app.command_line.stubs(:args).returns(['mytype'])
       Puppet::Type.stubs(:type).returns(@type)
+
+      @res = stub_everything "resource"
+      @res.stubs(:prune_parameters).returns(@res)
+      @report = stub_everything "report"
     end
 
     it "should raise an error if no type is given" do
-      @resource.command_line.stubs(:args).returns([])
-      lambda { @resource.main }.should raise_error
+      @resource_app.command_line.stubs(:args).returns([])
+      lambda { @resource_app.main }.should raise_error(RuntimeError, "You must specify the type to display")
     end
 
     it "should raise an error when editing a remote host" do
-      @resource.options.stubs(:[]).with(:edit).returns(true)
-      @resource.host = 'host'
+      @resource_app.options.stubs(:[]).with(:edit).returns(true)
+      @resource_app.host = 'host'
 
-      lambda { @resource.main }.should raise_error
+      lambda { @resource_app.main }.should raise_error(RuntimeError, "You cannot edit a remote host")
     end
 
     it "should raise an error if the type is not found" do
       Puppet::Type.stubs(:type).returns(nil)
 
-      lambda { @resource.main }.should raise_error
+      lambda { @resource_app.main }.should raise_error(RuntimeError, 'Could not find type mytype')
     end
 
     describe "with a host" do
       before :each do
-        @resource.stubs(:puts)
-        @resource.host = 'host'
+        @resource_app.stubs(:puts)
+        @resource_app.host = 'host'
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
@@ -159,36 +128,33 @@ describe Puppet::Application::Resource do
       end
 
       it "should search for resources" do
-        @resource.command_line.stubs(:args).returns(['type'])
+        @resource_app.command_line.stubs(:args).returns(['type'])
         Puppet::Resource.indirection.expects(:search).with('https://host:8139/production/resources/type/', {}).returns([])
-        @resource.main
+        @resource_app.main
       end
 
       it "should describe the given resource" do
-        @resource.command_line.stubs(:args).returns(['type', 'name'])
-        x = stub_everything 'resource'
-        Puppet::Resource.indirection.expects(:find).with('https://host:8139/production/resources/type/name').returns(x)
-        @resource.main
+        @resource_app.command_line.stubs(:args).returns(['type', 'name'])
+        Puppet::Resource.indirection.expects(:find).with('https://host:8139/production/resources/type/name').returns(@res)
+        @resource_app.main
       end
 
       it "should add given parameters to the object" do
-        @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
+        @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
 
-        res = stub "resource"
-        Puppet::Resource.indirection.expects(:save).with(res, 'https://host:8139/production/resources/type/name').returns(res)
-        res.expects(:collect)
-        res.expects(:to_manifest)
-        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
+        Puppet::Resource.indirection.expects(:save).
+          with(@res, 'https://host:8139/production/resources/type/name').
+          returns([@res, @report])
+        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
 
-        @resource.main
+        @resource_app.main
       end
-
     end
 
     describe "without a host" do
       before :each do
-        @resource.stubs(:puts)
-        @resource.host = nil
+        @resource_app.stubs(:puts)
+        @resource_app.host = nil
 
         Puppet::Resource.indirection.stubs(:find  ).never
         Puppet::Resource.indirection.stubs(:search).never
@@ -196,42 +162,37 @@ describe Puppet::Application::Resource do
       end
 
       it "should search for resources" do
-        Puppet::Resource.indirection.expects(:search).with('type/', {}).returns([])
-        @resource.main
+        Puppet::Resource.indirection.expects(:search).with('mytype/', {}).returns([])
+        @resource_app.main
       end
 
       it "should describe the given resource" do
-        @resource.command_line.stubs(:args).returns(['type','name'])
-        x = stub_everything 'resource'
-        Puppet::Resource.indirection.expects(:find).with('type/name').returns(x)
-        @resource.main
+        @resource_app.command_line.stubs(:args).returns(['type','name'])
+        Puppet::Resource.indirection.expects(:find).with('type/name').returns(@res)
+        @resource_app.main
       end
 
       it "should add given parameters to the object" do
-        @resource.command_line.stubs(:args).returns(['type','name','param=temp'])
+        @resource_app.command_line.stubs(:args).returns(['type','name','param=temp'])
 
-        res = stub "resource"
-        Puppet::Resource.indirection.expects(:save).with(res, 'type/name').returns(res)
-        res.expects(:collect)
-        res.expects(:to_manifest)
-        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(res)
+        Puppet::Resource.indirection.expects(:save).with(@res, 'type/name').returns([@res, @report])
+        Puppet::Resource.expects(:new).with('type', 'name', :parameters => {'param' => 'temp'}).returns(@res)
 
-        @resource.main
+        @resource_app.main
       end
-
     end
   end
 
   describe "when handling file type" do
     before :each do
       Facter.stubs(:loadfacts)
-      @resource.preinit
+      @resource_app.preinit
     end
 
     it "should raise an exception if no file specified" do
-      @resource.command_line.stubs(:args).returns(['file'])
+      @resource_app.command_line.stubs(:args).returns(['file'])
 
-      lambda { @resource.main }.should raise_error(RuntimeError, /Listing all file instances is not supported/)
+      lambda { @resource_app.main }.should raise_error(RuntimeError, /Listing all file instances is not supported/)
     end
 
     it "should output a file resource when given a file path" do
@@ -239,12 +200,12 @@ describe Puppet::Application::Resource do
       res = Puppet::Type.type(:file).new(:path => path).to_resource
       Puppet::Resource.indirection.expects(:find).returns(res)
 
-      @resource.command_line.stubs(:args).returns(['file', path])
-      @resource.expects(:puts).with do |args|
+      @resource_app.command_line.stubs(:args).returns(['file', path])
+      @resource_app.expects(:puts).with do |args|
         args.should =~ /file \{ '#{Regexp.escape(path)}'/m
       end
 
-      @resource.main
+      @resource_app.main
     end
   end
 end

data/spec/unit/configurer/downloader_spec.rb

@@ -97,8 +97,8 @@ describe Puppet::Configurer::Downloader do
 
   describe "when creating the catalog to do the downloading" do
     before do
-      @path = make_absolute("/download/path")
-      @dler = Puppet::Configurer::Downloader.new("foo", @path, "source")
+      @path = File.expand_path("/download/path")
+      @dler = Puppet::Configurer::Downloader.new("foo", @path, File.expand_path("source"))
     end
 
     it "should create a catalog and add the file to it" do

data/spec/unit/configurer/plugin_handler_spec.rb

@@ -75,18 +75,25 @@ describe Puppet::Configurer::PluginHandler do
     @pluginhandler.download_plugins
   end
 
-  it "should load plugins when asked to do so" do
+  it "should load ruby plugins when asked to do so" do
     FileTest.stubs(:exist?).returns true
-    @pluginhandler.expects(:load).with("foo")
+    @pluginhandler.expects(:load).with("foo.rb")
+
+    @pluginhandler.load_plugin("foo.rb")
+  end
+
+  it "should skip non-ruby plugins when asked to do so" do
+    FileTest.stubs(:exist?).returns true
+    @pluginhandler.expects(:load).never
 
     @pluginhandler.load_plugin("foo")
   end
 
   it "should not try to load files that don't exist" do
-    FileTest.expects(:exist?).with("foo").returns false
+    FileTest.expects(:exist?).with("foo.rb").returns false
     @pluginhandler.expects(:load).never
 
-    @pluginhandler.load_plugin("foo")
+    @pluginhandler.load_plugin("foo.rb")
   end
 
   it "should not try to load directories" do
@@ -99,17 +106,17 @@ describe Puppet::Configurer::PluginHandler do
 
   it "should warn but not fail if loading a file raises an exception" do
     FileTest.stubs(:exist?).returns true
-    @pluginhandler.expects(:load).with("foo").raises "eh"
+    @pluginhandler.expects(:load).with("foo.rb").raises "eh"
 
     Puppet.expects(:err)
-    @pluginhandler.load_plugin("foo")
+    @pluginhandler.load_plugin("foo.rb")
   end
 
   it "should warn but not fail if loading a file raises a LoadError" do
     FileTest.stubs(:exist?).returns true
-    @pluginhandler.expects(:load).with("foo").raises LoadError.new("eh")
+    @pluginhandler.expects(:load).with("foo.rb").raises LoadError.new("eh")
 
     Puppet.expects(:err)
-    @pluginhandler.load_plugin("foo")
+    @pluginhandler.load_plugin("foo.rb")
   end
 end

data/spec/unit/configurer_spec.rb

@@ -245,7 +245,7 @@ describe Puppet::Configurer do
       Puppet.settings[:prerun_command] = "/my/command"
       Puppet::Util.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
 
-      report.expects(:<<).with { |log| log.message =~ /^Could not run command from prerun_command/ }
+      report.expects(:<<).with { |log| log.message.include?("Could not run command from prerun_command") }
 
       @agent.run.should be_nil
     end
@@ -268,7 +268,7 @@ describe Puppet::Configurer do
       Puppet.settings[:postrun_command] = "/my/command"
       Puppet::Util.expects(:execute).with(["/my/command"]).raises(Puppet::ExecutionFailure, "Failed")
 
-      report.expects(:<<).with { |log| log.message =~ /^Could not run command from postrun_command/ }
+      report.expects(:<<).with { |log| log.message.include?("Could not run command from postrun_command") }
 
       @agent.run.should be_nil
     end

data/spec/unit/face/ca_spec.rb

@@ -174,6 +174,29 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
       list.length.should == 1
       list.first.name.should == 'random-host'
     end
+
+    describe "when the CSR specifies DNS alt names" do
+      let(:host) { Puppet::SSL::Host.new('someone') }
+
+      before :each do
+        host.generate_certificate_request(:dns_alt_names => 'some,alt,names')
+      end
+
+      it "should sign the CSR if DNS alt names are allowed" do
+        subject.sign('someone', :allow_dns_alt_names => true)
+
+        host.certificate.should be_a(Puppet::SSL::Certificate)
+      end
+
+      it "should refuse to sign the CSR if DNS alt names are not allowed" do
+        certname = 'someone'
+        expect do
+          subject.sign(certname)
+        end.to raise_error(Puppet::SSL::CertificateAuthority::CertificateSigningError, /CSR '#{certname}' contains subject alternative names \(.*\), which are disallowed. Use `puppet cert --allow-dns-alt-names sign #{certname}` to sign this request./i)
+
+        host.certificate.should be_nil
+      end
+    end
   end
 
   context "#generate" do
@@ -202,6 +225,17 @@ describe Puppet::Face[:ca, '0.1.0'], :unless => Puppet.features.microsoft_window
         subject.generate('random-host').should =~ /already has a certificate/
       }.should_not raise_error
     end
+
+    it "should include the specified DNS alt names" do
+      subject.generate('some-host', :dns_alt_names => 'some,alt,names')
+
+      host = subject.list(:signed => true).first
+
+      host.name.should == 'some-host'
+      host.certificate.subject_alt_names.should =~ %w[DNS:some DNS:alt DNS:names DNS:some-host]
+
+      subject.list(:pending => true).should be_empty
+    end
   end
 
   context "#revoke" do