puppet 2.7.13 → 2.7.14

data/spec/unit/provider/service/upstart_spec.rb

@@ -34,6 +34,7 @@ describe provider_class do
     it "should use the default status command if none is specified" do
       resource = Puppet::Type.type(:service).new(:name => "foo", :provider => :upstart)
       provider = provider_class.new(resource)
+      provider.stubs(:is_upstart?).returns(true)
 
       provider.expects(:status_exec).with(["foo"]).returns("foo start/running, process 1000")
       Process::Status.any_instance.stubs(:exitstatus).returns(0)
@@ -43,10 +44,47 @@ describe provider_class do
     it "should properly handle services with 'start' in their name" do
       resource = Puppet::Type.type(:service).new(:name => "foostartbar", :provider => :upstart)
       provider = provider_class.new(resource)
+      provider.stubs(:is_upstart?).returns(true)
 
       provider.expects(:status_exec).with(["foostartbar"]).returns("foostartbar stop/waiting")
       Process::Status.any_instance.stubs(:exitstatus).returns(0)
       provider.status.should == :stopped
+    end    
+  end
+  describe "inheritance" do
+    let :resource do
+      resource = Puppet::Type.type(:service).new(:name => "foo", :provider => :upstart)
+    end
+    
+    let :provider do
+      provider = provider_class.new(resource)
     end
+    
+    describe "when upstart job" do
+      before(:each) do
+        provider.stubs(:is_upstart?).returns(true)
+      end
+      ["start", "stop"].each do |command|
+        it "should return the #{command}cmd of its parent provider" do
+          provider.send("#{command}cmd".to_sym).should == [provider.command(command.to_sym), resource.name]
+        end
+      end
+      it "should return nil for the statuscmd" do
+        provider.statuscmd.should be_nil
+      end
+    end
+    
+    describe "when init script" do
+      before(:each) do
+        provider.stubs(:is_upstart?).returns(false)
+      end
+      ["start", "stop", "status"].each do |command|
+        it "should return the #{command}cmd of its parent provider" do
+          provider.expects(:search).with('foo').returns("/etc/init.d/foo")
+          provider.send("#{command}cmd".to_sym).should == ["/etc/init.d/foo", command.to_sym]
+        end
+      end
+    end
+
   end
 end

data/spec/unit/provider/ssh_authorized_key/parsed_spec.rb

@@ -80,6 +80,34 @@ describe provider_class, :unless => Puppet.features.microsoft_windows? do
 
     @provider_class.parse(line)[0][:name].should == ""
   end
+
+  ['ssh-dss', 'ssh-rsa', 'ecdsa-sha2-nistp256', 'ecdsa-sha2-nistp384', 'ecdsa-sha2-nistp521'].each do |keytype|
+    it "should be able to parse a #{keytype} key entry" do
+      # use some real world examples generated with ssh-keygen
+      key = case keytype
+        when 'ssh-dss' # ssh-keygen -t dsa -b 1024
+          'AAAAB3NzaC1kc3MAAACBANGTefWMXS780qLMMgysq3GNMKzg55LXZODif6Tqv1vtTh4Wuk3J5X5u644jTyNdAIn1RiBI9MnwnZMZ6nXKvucMcMQWMibYS9W2MhkRj3oqsLWMMsdGXJL18SWM5A6oC3oIRC4JHJZtkm0OctR2trKxmX+MGhdCd+Xpsh9CNK8XAAAAFQD4olFiwv+QQUFdaZbWUy1CLEG9xQAAAIByCkXKgoriZF8bQ0OX1sKuR69M/6n5ngmQGVBKB7BQkpUjbK/OggB6iJgst5utKkDcaqYRnrTYG9q3jJ/flv7yYePuoSreS0nCMMx9gpEYuq+7Sljg9IecmN/IHrNd9qdYoASy5iuROQMvEZM7KFHA8vBv0tWdBOsp4hZKyiL1DAAAAIEAjkZlOps9L+cD/MTzxDj7toYYypdLOvjlcPBaglkPZoFZ0MAKTI0zXlVX1cWAnkd0Yfo4EpP+6XAjlZkod+QXKXM4Tb4PnR34ASMeU6sEjM61Na24S7JD3gpPKataFU/oH3hzXsBdK2ttKYmoqvf61h32IA/3Z5PjCCD9pPLPpAY'
+        when 'ssh-rsa' # ssh-keygen -t rsa -b 2048
+          'AAAAB3NzaC1yc2EAAAADAQABAAABAQDYtEaWa1mlxaAh9vtiz6RCVKDiJHDY15nsqqWU7F7A1+U1498+sWDyRDkZ8vXWQpzyOMBzBSHIxhsprlKhkjomy8BuJP+bHDBIKx4zgSFDrklrPIf467Iuug8J0qqDLxO4rOOjeAiLEyC0t2ZGnsTEea+rmat0bJ2cv3g5L4gH/OFz2pI4ZLp1HGN83ipl5UH8CjXQKwo3Db1E3WJCqKgszVX0Z4/qjnBRxFMoqky/1mGb/mX1eoT9JyQ8OhU9uENZOShkksSpgUqjlrjpj0Yd14hBlnE3M18pE4ivxjzectA/XRKNZaxOL1YREtU8sXusAwmlEY4aJ64aR0JrXfgx'
+        when 'ecdsa-sha2-nistp256' # ssh-keygen -t ecdsa -b 256
+          'AAAAE2VjZHNhLXNoYTItbmlzdHAyNTYAAAAIbmlzdHAyNTYAAABBBBO5PfBf0c2jAuqD+Lj3j+SuXOXNT2uqESLVOn5jVQfEF9GzllOw+CMOpUvV1CiOOn+F1ET15vcsfmD7z05WUTA='
+        when 'ecdsa-sha2-nistp384' # ssh-keygen -t ecdsa -b 384
+          'AAAAE2VjZHNhLXNoYTItbmlzdHAzODQAAAAIbmlzdHAzODQAAABhBJIfxNoVK4FX3RuMlkHOwwxXwAh6Fqx5uAp4ftXrJ+64qYuIzb+/zSAkJV698Sre1b1lb0G4LyDdVAvXwaYK9kN25vy8umV3WdfZeHKXJGCcrplMCbbOERWARlpiPNEblg=='
+        when 'ecdsa-sha2-nistp521' #ssh-keygen -t ecdsa -b 521
+          'AAAAE2VjZHNhLXNoYTItbmlzdHA1MjEAAAAIbmlzdHA1MjEAAACFBADLK+u12xwB0JOwpmaxYXv8KnPK4p+SE2405qoo+vpAQ569fMwPMgKzltd770amdeuFogw/MJu17PN9LDdrD3o0uwHMjWee6TpHQDkuEetaxiou6K0WAzgbxx9QsY0MsJgXf1BuMLqdK+xT183wOSXwwumv99G7T32dOJZ5tYrH0y4XMw=='
+        else
+          pending("No sample key for #{keytype} yet")
+      end
+      comment = 'sample_key'
+
+      record = @provider_class.parse_line("#{keytype} #{key} #{comment}")
+      record.should_not be_nil
+      record[:name].should == comment
+      record[:key].should == key
+      record[:type].should == keytype
+    end
+  end
+
 end
 
 describe provider_class, :unless => Puppet.features.microsoft_windows? do

data/spec/unit/rails/host_spec.rb

@@ -3,16 +3,10 @@ require 'spec_helper'
 
 require 'puppet/node/environment'
 
-describe "Puppet::Rails::Host", :if => Puppet.features.rails? do
-  def column(name, type)
-    ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
-  end
-
+describe "Puppet::Rails::Host", :if => can_use_scratch_database? do
   before do
     require 'puppet/rails/host'
-
-    # Stub this so we don't need access to the DB.
-    Puppet::Rails::Host.stubs(:columns).returns([column("name", "string"), column("environment", "string"), column("ip", "string")])
+    setup_scratch_database
 
     @node = Puppet::Node.new("foo")
     @node.environment = "production"
@@ -96,7 +90,7 @@ describe "Puppet::Rails::Host", :if => Puppet.features.rails? do
 
   describe "when merging catalog resources and database resources" do
     before :each do
-      Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(false)
+      Puppet[:thin_storeconfigs] = false
       @resource1 = stub_everything 'res1'
       @resource2 = stub_everything 'res2'
       @resources = [ @resource1, @resource2 ]
@@ -131,7 +125,7 @@ describe "Puppet::Rails::Host", :if => Puppet.features.rails? do
     end
 
     it "should compare only exported resources in thin_storeconfigs mode" do
-      Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(true)
+      Puppet[:thin_storeconfigs] = true
       @resource1.stubs(:exported?).returns(true)
 
       @host.expects(:compare_to_catalog).with(@dbresources, [ @resource1 ])
@@ -142,7 +136,7 @@ describe "Puppet::Rails::Host", :if => Puppet.features.rails? do
 
   describe "when searching the database for host resources" do
     before :each do
-      Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(false)
+      Puppet[:thin_storeconfigs] = false
       @resource1 = stub_everything 'res1', :id => 1
       @resource2 = stub_everything 'res2', :id => 2
       @resources = [ @resource1, @resource2 ]
@@ -159,7 +153,7 @@ describe "Puppet::Rails::Host", :if => Puppet.features.rails? do
     end
 
     it "should return a hash keyed by id of only exported resources in thin_storeconfigs mode" do
-      Puppet.settings.stubs(:[]).with(:thin_storeconfigs).returns(true)
+      Puppet[:thin_storeconfigs] = true
       @dbresources.expects(:find).with { |*h| h[1][:conditions] == { :exported => true } }.returns([])
 
       @host.find_resources

data/spec/unit/rails/param_value_spec.rb

@@ -2,18 +2,13 @@
 require 'spec_helper'
 require 'puppet/rails'
 
-describe "Puppet::Rails::ParamValue", :if => Puppet.features.rails? do
-  def column(name, type)
-    ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
-  end
-
+describe "Puppet::Rails::ParamValue", :if => can_use_scratch_database? do
   before do
     require 'puppet/rails/param_value'
-
-    name = stub 'param_name', :name => "foo"
+    setup_scratch_database
 
     # Stub this so we don't need access to the DB.
-    Puppet::Rails::ParamValue.stubs(:columns).returns([column("value", "string")])
+    name = stub 'param_name', :name => "foo"
     Puppet::Rails::ParamName.stubs(:find_or_create_by_name).returns(name)
   end
 

data/spec/unit/rails/resource_spec.rb

@@ -2,16 +2,10 @@
 require 'spec_helper'
 require 'puppet/rails'
 
-describe "Puppet::Rails::Resource", :if => Puppet.features.rails? do
-  def column(name, type)
-    ActiveRecord::ConnectionAdapters::Column.new(name, nil, type, false)
-  end
-
+describe "Puppet::Rails::Resource", :if => can_use_scratch_database? do
   before do
     require 'puppet/rails/resource'
-
-    # Stub this so we don't need access to the DB.
-    Puppet::Rails::Resource.stubs(:columns).returns([column("title", "string"), column("restype", "string"), column("exported", "boolean")])
+    setup_scratch_database
   end
 
   describe "when creating initial resource arguments" do

data/spec/unit/reports/http_spec.rb

@@ -1,55 +1,71 @@
 #!/usr/bin/env rspec
 require 'spec_helper'
-
 require 'puppet/reports'
 
-# FakeHTTP fakes the behavior of Net::HTTP#request and acts as a sensor for an
-# otherwise difficult to trace method call.
-#
-class FakeHTTP
-  REQUESTS = {}
-  def self.request(req)
-    REQUESTS[req.path] = req
-  end
-end
-
 processor = Puppet::Reports.report(:http)
 
 describe processor do
-  before  { Net::HTTP.any_instance.stubs(:start).yields(FakeHTTP) }
   subject { Puppet::Transaction::Report.new("apply").extend(processor) }
 
-  it { should respond_to(:process) }
-
   it "should use the reporturl setting's host and port" do
     uri = URI.parse(Puppet[:reporturl])
     Net::HTTP.expects(:new).with(uri.host, uri.port).returns(stub_everything('http'))
     subject.process
   end
 
-  describe "request" do
-    before { subject.process }
+  describe "when making a request" do
+    let(:http) { mock "http" }
+    let(:httpok) { Net::HTTPOK.new('1.1', 200, '') }
 
-    describe "path" do
-      it "should use the path specified by the 'reporturl' setting" do
-        reports_request.path.should == URI.parse(Puppet[:reporturl]).path
-      end
+    before :each do
+      Net::HTTP.any_instance.expects(:start).yields(http)
     end
 
-    describe "body" do
-      it "should be the report as YAML" do
-        reports_request.body.should == subject.to_yaml
-      end
+    it "should use the path specified by the 'reporturl' setting" do
+      http.expects(:request).with {|req|
+        req.path.should == URI.parse(Puppet[:reporturl]).path
+      }.returns(httpok)
+
+      subject.process
     end
 
-    describe "content type" do
-      it "should be 'application/x-yaml'" do
-        reports_request.content_type.should == "application/x-yaml"
-      end
+    it "should give the body as the report as YAML" do
+      http.expects(:request).with {|req|
+        req.body.should == subject.to_yaml
+      }.returns(httpok)
+
+      subject.process
     end
-  end
 
-  private
+    it "should set content-type to 'application/x-yaml'" do
+      http.expects(:request).with {|req|
+        req.content_type.should == "application/x-yaml"
+      }.returns(httpok)
 
-  def reports_request; FakeHTTP::REQUESTS[URI.parse(Puppet[:reporturl]).path] end
+      subject.process
+    end
+
+    Net::HTTPResponse::CODE_TO_OBJ.each do |code, klass|
+      if code.to_i >= 200 and code.to_i < 300
+        it "should succeed on http code #{code}" do
+          response = klass.new('1.1', code, '')
+          http.expects(:request).returns(response)
+
+          Puppet.expects(:err).never
+          subject.process
+        end
+      end
+
+      if code.to_i >= 300
+        it "should log error on http code #{code}" do
+          response = klass.new('1.1', code, '')
+          http.expects(:request).returns(response)
+
+          Puppet.expects(:err)
+          subject.process
+        end
+      end
+    end
+
+  end
 end

data/spec/unit/reports/tagmail_spec.rb

@@ -88,4 +88,81 @@ describe tagmail do
       results.should be_nil
     end
   end
+
+  describe "the behavior of tagmail.process" do
+    before do
+      Puppet[:tagmap] = my_fixture "tagmail_email.conf"
+    end
+
+    let(:processor) do
+      processor = Puppet::Transaction::Report.new("apply")
+      processor.extend(Puppet::Reports.report(:tagmail))
+      processor
+    end
+
+    context "when any messages match a positive tag" do
+      before do
+        processor << log_entry
+      end
+
+      let(:log_entry) do
+        Puppet::Util::Log.new(
+          :level => :notice, :message => "Secure change", :tags => %w{secure})
+      end
+
+      let(:message) do
+        "#{log_entry.time} Puppet (notice): Secure change"
+      end
+
+      it "should send email if there are changes" do
+        processor.expects(:send).with([[['user@domain.com'], message]])
+        processor.expects(:raw_summary).returns({
+          "resources" => { "changed" => 1, "out_of_sync" => 0 }
+        })
+
+        processor.process
+      end
+
+      it "should send email if there are resources out of sync" do
+        processor.expects(:send).with([[['user@domain.com'], message]])
+        processor.expects(:raw_summary).returns({
+          "resources" => { "changed" => 0, "out_of_sync" => 1 }
+        })
+
+        processor.process
+      end
+
+      it "should not send email if no changes or resources out of sync" do
+        processor.expects(:send).never
+        processor.expects(:raw_summary).returns({
+          "resources" => { "changed" => 0, "out_of_sync" => 0 }
+        })
+
+        processor.process
+      end
+
+      it "should log a message if no changes or resources out of sync" do
+        processor.expects(:send).never
+        processor.expects(:raw_summary).returns({
+          "resources" => { "changed" => 0, "out_of_sync" => 0 }
+        })
+
+        Puppet.expects(:notice).with("Not sending tagmail report; no changes")
+        processor.process
+      end
+
+      it "should send email if raw_summary is not defined" do
+        processor.expects(:send).with([[['user@domain.com'], message]])
+        processor.expects(:raw_summary).returns(nil)
+        processor.process
+      end
+
+      it "should send email if there are no resource metrics" do
+        processor.expects(:send).with([[['user@domain.com'], message]])
+        processor.expects(:raw_summary).returns({'resources' => nil})
+        processor.process
+      end
+    end
+  end
 end
+

data/spec/unit/resource/type_spec.rb

@@ -238,7 +238,7 @@ describe Puppet::Resource::Type do
 
   describe "when setting its parameters in the scope" do
     before do
-      @scope = Puppet::Parser::Scope.new(:compiler => stub("compiler", :environment => Puppet::Node::Environment.new), :source => stub("source"))
+      @scope = Puppet::Parser::Scope.new(:compiler => Puppet::Parser::Compiler.new(Puppet::Node.new("foo")), :source => stub("source"))
       @resource = Puppet::Parser::Resource.new(:foo, "bar", :scope => @scope)
       @type = Puppet::Resource::Type.new(:hostclass, "foo")
     end
@@ -435,7 +435,7 @@ describe Puppet::Resource::Type do
 
     it "should set all of its parameters in a subscope" do
       subscope = stub 'subscope', :compiler => @compiler
-      @scope.expects(:newscope).with(:source => @type, :dynamic => true, :namespace => 'foo', :resource => @resource).returns subscope
+      @scope.expects(:newscope).with(:source => @type, :namespace => 'foo', :resource => @resource).returns subscope
       @type.expects(:set_resource_parameters).with(@resource, subscope)
 
       @type.evaluate_code(@resource)

data/spec/unit/resource_spec.rb

@@ -5,9 +5,7 @@ require 'puppet/resource'
 describe Puppet::Resource do
   include PuppetSpec::Files
 
-  before do
-    @basepath = make_absolute("/somepath")
-  end
+  let :basepath do make_absolute("/somepath") end
 
   [:catalog, :file, :line].each do |attr|
     it "should have an #{attr} attribute" do
@@ -87,27 +85,27 @@ describe Puppet::Resource do
   end
 
   it "should be able to extract its information from a Puppet::Type instance" do
-    ral = Puppet::Type.type(:file).new :path => @basepath+"/foo"
+    ral = Puppet::Type.type(:file).new :path => basepath+"/foo"
     ref = Puppet::Resource.new(ral)
     ref.type.should == "File"
-    ref.title.should == @basepath+"/foo"
+    ref.title.should == basepath+"/foo"
   end
 
 
   it "should fail if the title is nil and the type is not a valid resource reference string" do
-    lambda { Puppet::Resource.new("foo") }.should raise_error(ArgumentError)
+    expect { Puppet::Resource.new("resource-spec-foo") }.should raise_error(ArgumentError)
   end
 
   it 'should fail if strict is set and type does not exist' do
-    lambda { Puppet::Resource.new('foo', 'title', {:strict=>true}) }.should raise_error(ArgumentError, 'Invalid resource type foo')
+    expect { Puppet::Resource.new('resource-spec-foo', 'title', {:strict=>true}) }.should raise_error(ArgumentError, 'Invalid resource type resource-spec-foo')
   end
 
   it 'should fail if strict is set and class does not exist' do
-    lambda { Puppet::Resource.new('Class', 'foo', {:strict=>true}) }.should raise_error(ArgumentError, 'Could not find declared class foo')
+    expect { Puppet::Resource.new('Class', 'resource-spec-foo', {:strict=>true}) }.should 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
-    expect { Puppet::Resource.new({:type => "foo", :title => "bar"}) }.
+    expect { Puppet::Resource.new({:type => "resource-spec-foo", :title => "bar"}) }.
       to raise_error ArgumentError, /Puppet::Resource.new does not take a hash/
   end
 
@@ -286,11 +284,11 @@ describe Puppet::Resource do
     end
 
     it "should fail if invalid parameters are used" do
-      lambda { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.should raise_error
+      expect { Puppet::Resource.new("file", "/path", :strict => true, :parameters => {:nosuchparam => "bar"}) }.should raise_error
     end
 
     it "should fail if the resource type cannot be resolved" do
-      lambda { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.should raise_error
+      expect { Puppet::Resource.new("nosuchtype", "/path", :strict => true) }.should raise_error
     end
   end
 
@@ -355,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"
-      lambda { resource[:name] = "eh" }.should_not raise_error
+      expect { resource[:name] = "eh" }.should_not raise_error
     end
 
     it "should be able to return the name for non-builtin types" do
@@ -472,7 +470,7 @@ type: File
     end
 
     it "should deserialize a Puppet::Resource::Reference without exceptions" do
-      lambda { YAML.load(@old_storedconfig_yaml) }.should_not raise_error
+      expect { YAML.load(@old_storedconfig_yaml) }.should_not raise_error
     end
 
     it "should deserialize as a Puppet::Resource::Reference as a Puppet::Resource" do
@@ -486,10 +484,10 @@ type: File
 
   describe "when converting to a RAL resource" do
     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")
+      resource = Puppet::Resource.new("file", basepath+"/my/file")
       result = resource.to_ral
       result.should be_instance_of(Puppet::Type.type(:file))
-      result[:path].should == @basepath+"/my/file"
+      result[:path].should == basepath+"/my/file"
     end
 
     it "should convert to a component instance if the resource type is not of a builtin type" do
@@ -526,7 +524,7 @@ type: File
   describe "when converting to a TransObject" do
     describe "and the resource is not an instance of a builtin type" do
       before do
-        @resource = Puppet::Resource.new("foo", "bar")
+        @resource = Puppet::Resource.new("resource-spec-foo", "bar")
       end
 
       it "should return a simple TransBucket if it is not an instance of a builtin type" do
@@ -697,7 +695,7 @@ type: File
     before do
       @data = {
         'type' => "file",
-        'title' => @basepath+"/yay",
+        'title' => basepath+"/yay",
       }
     end
 
@@ -706,7 +704,7 @@ type: File
     end
 
     it "should set its title to the provided title" do
-      Puppet::Resource.from_pson(@data).title.should == @basepath+"/yay"
+      Puppet::Resource.from_pson(@data).title.should == basepath+"/yay"
     end
 
     it "should tag the resource with any provided tags" do
@@ -737,12 +735,12 @@ type: File
 
     it "should fail if no title is provided" do
       @data.delete('title')
-      lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
+      expect { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
     end
 
     it "should fail if no type is provided" do
       @data.delete('type')
-      lambda { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
+      expect { Puppet::Resource.from_pson(@data) }.should raise_error(ArgumentError)
     end
 
     it "should set each of the provided parameters" do