puppet 2.6.6 → 2.6.7

data/spec/integration/type/file_spec.rb

@@ -173,7 +173,12 @@ describe Puppet::Type.type(:file) do
     it "should be able to recurse over a nonexistent file" do
       @path = tmpfile("file_integration_tests")
 
-      @file = Puppet::Type::File.new(:name => @path, :mode => 0644, :recurse => true, :backup => false)
+      @file = Puppet::Type::File.new(
+        :name    => @path,
+        :mode    => 0644,
+        :recurse => true,
+        :backup  => false
+      )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
@@ -186,7 +191,12 @@ describe Puppet::Type.type(:file) do
 
       build_path(@path)
 
-      @file = Puppet::Type::File.new(:name => @path, :mode => 0644, :recurse => true, :backup => false)
+      @file = Puppet::Type::File.new(
+        :name    => @path,
+        :mode    => 0644,
+        :recurse => true,
+        :backup  => false
+      )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @file
@@ -393,10 +403,8 @@ describe Puppet::Type.type(:file) do
     dest = tmpfile("files_with_content")
 
 
-          file = Puppet::Type.type(:file).new(
-                
-      :name => dest,
-        
+    file = Puppet::Type.type(:file).new(
+      :name    => dest,
       :content => "this is some content, yo"
     )
 
@@ -411,11 +419,9 @@ describe Puppet::Type.type(:file) do
     dest = tmpfile("files_with_content")
 
 
-          file = Puppet::Type.type(:file).new(
-                
-      :name => dest,
-      :ensure => "file",
-        
+    file = Puppet::Type.type(:file).new(
+      :name    => dest,
+      :ensure  => "file",
       :content => "this is some content, yo"
     )
 
@@ -433,12 +439,10 @@ describe Puppet::Type.type(:file) do
     File.open(dest, "w") { |f| f.puts "boo" }
 
 
-          file = Puppet::Type.type(:file).new(
-                
-      :name => dest,
+    file = Puppet::Type.type(:file).new(
+      :name   => dest,
       :ensure => :absent,
       :source => source,
-        
       :backup => false
     )
 
@@ -465,24 +469,23 @@ describe Puppet::Type.type(:file) do
       File.open(@purgee, "w") { |f| f.puts "footest" }
 
 
-            @lfobj = Puppet::Type.newfile(
-                
-        :title => "localfile",
-        :path => @localfile,
+      @lfobj = Puppet::Type.newfile(
+        :title   => "localfile",
+        :path    => @localfile,
         :content => "rahtest\n",
-        :ensure => :file,
-        
-        :backup => false
+        :ensure  => :file,
+        :backup  => false
       )
 
 
-            @destobj = Puppet::Type.newfile(
-        :title => "destdir", :path => @destdir,
-                    :source => @sourcedir,
-                    :backup => false,
-                    :purge => true,
-        
-                    :recurse => true)
+      @destobj = Puppet::Type.newfile(
+        :title   => "destdir",
+        :path    => @destdir,
+        :source  => @sourcedir,
+        :backup  => false,
+        :purge   => true,
+        :recurse => true
+      )
 
       @catalog = Puppet::Resource::Catalog.new
       @catalog.add_resource @lfobj, @destobj

data/spec/spec_helper.rb

@@ -34,6 +34,7 @@ RSpec.configure do |config|
     Puppet.settings.clear
     Puppet::Node::Environment.clear
     Puppet::Util::Storage.clear
+    Puppet::Util::ExecutionStub.reset
 
     if defined?($tmpfiles)
       $tmpfiles.each do |file|
@@ -64,6 +65,7 @@ RSpec.configure do |config|
     # these globals are set by Application
     $puppet_application_mode = nil
     $puppet_application_name = nil
+    Signal.stubs(:trap)
 
     # Set the confdir and vardir to gibberish so that tests
     # have to be correctly mocked.

data/spec/unit/application/agent_spec.rb

@@ -50,12 +50,8 @@ describe Puppet::Application::Agent do
   end
 
   describe "in preinit" do
-    before :each do
-      @puppetd.stubs(:trap)
-    end
-
     it "should catch INT" do
-      @puppetd.expects(:trap).with { |arg,block| arg == :INT }
+      Signal.expects(:trap).with { |arg,block| arg == :INT }
 
       @puppetd.preinit
     end
@@ -530,11 +526,11 @@ describe Puppet::Application::Agent do
           @puppetd.onetime
         end
 
-        it "should always exit with 0 if --noop" do
+        it "should exit with the report's computer exit status, even if --noop is set." do
           Puppet.stubs(:[]).with(:noop).returns(true)
           report = stub 'report', :exit_status => 666
           @agent.stubs(:run).returns(report)
-          @puppetd.expects(:exit).with(0)
+          @puppetd.expects(:exit).with(666)
 
           @puppetd.onetime
         end

data/spec/unit/application/apply_spec.rb

@@ -52,7 +52,6 @@ describe Puppet::Application::Apply do
 
     before :each do
       Puppet::Log.stubs(:newdestination)
-      Puppet.stubs(:trap)
       Puppet::Log.stubs(:level=)
       Puppet.stubs(:parse_config)
       Puppet::FileBucket::Dipper.stubs(:new)
@@ -78,7 +77,7 @@ describe Puppet::Application::Apply do
     end
 
     it "should set INT trap" do
-      @apply.expects(:trap).with(:INT)
+      Signal.expects(:trap).with(:INT)
 
       @apply.setup
     end
@@ -167,6 +166,13 @@ describe Puppet::Application::Apply do
         @apply.expects(:exit).with(1)
         @apply.parseonly
       end
+
+      it "should exit with exit code 1 if error, even if --noop is set" do
+        Puppet[:noop] = true
+        @collection.stubs(:perform_initial_import).raises(Puppet::ParseError)
+        @apply.expects(:exit).with(1)
+        @apply.parseonly
+      end
     end
 
     describe "the main command" do
@@ -328,6 +334,15 @@ describe Puppet::Application::Apply do
           @apply.main
         end
 
+        it "should exit with report's computed exit status, even if --noop is set" do
+          Puppet.stubs(:[]).with(:noop).returns(true)
+          @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(true)
+          Puppet::Transaction::Report.any_instance.stubs(:exit_status).returns(666)
+          @apply.expects(:exit).with(666)
+
+          @apply.main
+        end
+
         it "should always exit with 0 if option is disabled" do
           Puppet.stubs(:[]).with(:noop).returns(false)
           @apply.options.stubs(:[]).with(:detailed_exitcodes).returns(false)

data/spec/unit/application/cert_spec.rb

@@ -51,7 +51,7 @@ describe Puppet::Application::Cert do
 
   it "should set cert_mode to :destroy for --clean" do
     @cert_app.handle_clean(0)
-    @cert_app.cert_mode.should == :destroy
+    @cert_app.subcommand.should == :destroy
   end
 
   it "should set all to true for --all" do
@@ -68,7 +68,7 @@ describe Puppet::Application::Cert do
     it "should set cert_mode to #{method} with option --#{method}" do
       @cert_app.send("handle_#{method}".to_sym, nil)
 
-      @cert_app.cert_mode.should == method
+      @cert_app.subcommand.should == method
     end
   end
 
@@ -114,19 +114,19 @@ describe Puppet::Application::Cert do
     end
 
     it "should set the ca_location to :local if the cert_mode is generate" do
-      @cert_app.find_mode('--generate')
+      @cert_app.subcommand = 'generate'
       Puppet::SSL::Host.expects(:ca_location=).with(:local)
       @cert_app.setup
     end
 
     it "should set the ca_location to :local if the cert_mode is destroy" do
-      @cert_app.find_mode('--destroy')
+      @cert_app.subcommand = 'destroy'
       Puppet::SSL::Host.expects(:ca_location=).with(:local)
       @cert_app.setup
     end
 
     it "should set the ca_location to :only if the cert_mode is print" do
-      @cert_app.find_mode('--print')
+      @cert_app.subcommand = 'print'
       Puppet::SSL::Host.expects(:ca_location=).with(:only)
       @cert_app.setup
     end
@@ -171,24 +171,64 @@ describe Puppet::Application::Cert do
       @cert_app.main
     end
 
-    it "should delegate to ca.apply with current set cert_mode" do
-      @cert_app.cert_mode = "currentmode"
+    it "should revoke cert if cert_mode is clean" do
+      @cert_app.subcommand = :destroy
       @cert_app.command_line.stubs(:args).returns(["host"])
 
-      @ca.expects(:apply).with { |cert_mode,to| cert_mode == "currentmode" }
+      @ca.expects(:apply).with { |cert_mode,to| cert_mode == :revoke }
+      @ca.expects(:apply).with { |cert_mode,to| cert_mode == :destroy }
 
       @cert_app.main
     end
+  end
 
-    it "should revoke cert if cert_mode is clean" do
-      @cert_app.cert_mode = :destroy
-      @cert_app.command_line.stubs(:args).returns(["host"])
+  describe "when identifying subcommands" do
+    before :each do
+      @cert_app.all = false
+      @ca = stub_everything 'ca'
+      @cert_app.ca = @ca
+    end
 
-      @ca.expects(:apply).with { |cert_mode,to| cert_mode == :revoke }
-      @ca.expects(:apply).with { |cert_mode,to| cert_mode == :destroy }
+    it "should not fail when no command is given" do
+      # Make the help method silent for testing; this is a bit nasty, but we
+      # can't identify a cleaner method.  Help welcome. --daniel 2011-02-22
+      Puppet.features.stubs(:usage?).returns(false)
+      @cert_app.stubs(:puts)
 
-      @cert_app.main
+      @cert_app.command_line.stubs(:args).returns([])
+      expect { @cert_app.parse_options }.should raise_error SystemExit
     end
 
+    %w{list revoke generate sign print verify fingerprint}.each do |cmd|
+      short = cmd[0,1]
+      [cmd, "--#{cmd}", "-#{short}"].each do |option|
+        # In our command line '-v' was eaten by 'verbose', so we can't consume
+        # it here; this is a special case from our otherwise standard
+        # processing. --daniel 2011-02-22
+        next if option == "-v"
+
+        it "should recognise '#{option}'" do
+          args = [option, "fun.example.com"]
+
+          @cert_app.command_line.stubs(:args).returns(args)
+          @cert_app.parse_options
+          @cert_app.subcommand.should == cmd.to_sym
+
+          args.should == ["fun.example.com"]
+        end
+      end
+    end
+
+    %w{clean --clean -c}.each do |ugly|
+      it "should recognise the '#{ugly}' option as destroy" do
+        args = [ugly, "fun.example.com"]
+
+        @cert_app.command_line.stubs(:args).returns(args)
+        @cert_app.parse_options
+        @cert_app.subcommand.should == :destroy
+
+        args.should == ["fun.example.com"]
+      end
+    end
   end
 end

data/spec/unit/application/filebucket_spec.rb

@@ -56,7 +56,7 @@ describe Puppet::Application::Filebucket do
     end
 
     it "should trap INT" do
-      @filebucket.expects(:trap).with(:INT)
+      Signal.expects(:trap).with(:INT)
 
       @filebucket.setup
     end

data/spec/unit/application/queue_spec.rb

@@ -29,12 +29,8 @@ describe Puppet::Application::Queue do
   end
 
   describe "in preinit" do
-    before :each do
-      @queue.stubs(:trap)
-    end
-
     it "should catch INT" do
-      @queue.expects(:trap).with { |arg,block| arg == :INT }
+      Signal.expects(:trap).with { |arg,block| arg == :INT }
 
       @queue.preinit
     end

data/spec/unit/configurer/downloader_spec.rb

@@ -5,6 +5,8 @@ require File.dirname(__FILE__) + '/../../spec_helper'
 require 'puppet/configurer/downloader'
 
 describe Puppet::Configurer::Downloader do
+  require 'puppet_spec/files'
+  include PuppetSpec::Files
   it "should require a name" do
     lambda { Puppet::Configurer::Downloader.new }.should raise_error(ArgumentError)
   end
@@ -96,25 +98,35 @@ describe Puppet::Configurer::Downloader do
 
   describe "when creating the catalog to do the downloading" do
     before do
-      @dler = Puppet::Configurer::Downloader.new("foo", "path", "source")
+      @dler = Puppet::Configurer::Downloader.new("foo", "/download/path", "source")
     end
 
     it "should create a catalog and add the file to it" do
-      file = mock 'file'
-      catalog = mock 'catalog'
-
-      @dler.expects(:file).returns file
-
-      Puppet::Resource::Catalog.expects(:new).returns catalog
-      catalog.expects(:add_resource).with(file)
+      catalog = @dler.catalog
+      catalog.resources.size.should == 1
+      catalog.resources.first.class.should == Puppet::Type::File
+      catalog.resources.first.name.should == "/download/path"
+    end
 
-      @dler.catalog.should equal(catalog)
+    it "should specify that it is not managing a host catalog" do
+      @dler.catalog.host_config.should == false
     end
+
   end
 
   describe "when downloading" do
     before do
-      @dler = Puppet::Configurer::Downloader.new("foo", "path", "source")
+      @dl_name = tmpfile("downloadpath")
+      source_name = tmpfile("source")
+      File.open(source_name, 'w') {|f| f.write('hola mundo') }
+      @dler = Puppet::Configurer::Downloader.new("foo", @dl_name, source_name)
+    end
+
+    it "should not skip downloaded resources when filtering on tags" do
+      Puppet[:tags] = 'maytag'
+      @dler.evaluate
+
+      File.exists?(@dl_name).should be_true
     end
 
     it "should log that it is downloading" do

data/spec/unit/daemon_spec.rb

@@ -29,13 +29,9 @@ describe Puppet::Daemon do
   end
 
   describe "when setting signal traps" do
-    before do
-      @daemon.stubs(:trap)
-    end
-
     {:INT => :stop, :TERM => :stop, :HUP => :restart, :USR1 => :reload, :USR2 => :reopen_logs}.each do |signal, method|
       it "should log and call #{method} when it receives #{signal}" do
-        @daemon.expects(:trap).with(signal).yields
+        Signal.expects(:trap).with(signal).yields
 
         Puppet.expects(:notice)
 

data/spec/unit/indirector/facts/inventory_active_record_spec.rb

@@ -0,0 +1,163 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../../../spec_helper'
+require 'sqlite3' rescue nil
+require 'tempfile'
+require 'puppet/rails'
+
+describe "Puppet::Node::Facts::InventoryActiveRecord", :if => (Puppet.features.rails? and defined? SQLite3) do
+  let(:terminus) { Puppet::Node::Facts::InventoryActiveRecord.new }
+
+  before :all do
+    require 'puppet/indirector/facts/inventory_active_record'
+    @dbfile = Tempfile.new("testdb")
+    @dbfile.close
+  end
+
+  after :all do
+    Puppet::Node::Facts.indirection.reset_terminus_class
+    @dbfile.unlink
+  end
+
+  before :each do
+    Puppet::Node::Facts.terminus_class = :inventory_active_record
+    Puppet[:dbadapter]  = 'sqlite3'
+    Puppet[:dblocation] = @dbfile.path
+    Puppet[:railslog] = "/dev/null"
+    Puppet::Rails.init
+  end
+
+  after :each do
+    Puppet::Rails.teardown
+  end
+
+  describe "#save" do
+    it "should use an existing node if possible" do
+      node = Puppet::Rails::InventoryNode.new(:name => "foo", :timestamp => Time.now)
+      node.save
+      Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin").save
+
+      Puppet::Rails::InventoryNode.count.should == 1
+      Puppet::Rails::InventoryNode.first.should == node
+    end
+
+    it "should create a new node if one can't be found" do
+      # This test isn't valid if there are nodes to begin with
+      Puppet::Rails::InventoryNode.count.should == 0
+
+      Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin").save
+
+      Puppet::Rails::InventoryNode.count.should == 1
+      Puppet::Rails::InventoryNode.first.name.should == "foo"
+    end
+
+    it "should save the facts" do
+      Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin").save
+
+      Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should =~ [["uptime_days","60"],["kernel","Darwin"]]
+    end
+
+    it "should remove the previous facts for an existing node" do
+      Puppet::Node::Facts.new("foo", "uptime_days" => "30", "kernel" => "Darwin").save
+      bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "35", "kernel" => "Linux")
+      foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "is_virtual" => "false")
+      bar_facts.save
+      foo_facts.save
+
+      Puppet::Node::Facts.find("bar").should == bar_facts
+      Puppet::Node::Facts.find("foo").should == foo_facts
+      Puppet::Rails::InventoryFact.all.map{|f| [f.name,f.value]}.should_not include(["uptime_days", "30"], ["kernel", "Darwin"])
+    end
+  end
+
+  describe "#find" do
+    before do
+      @foo_facts = Puppet::Node::Facts.new("foo", "uptime_days" => "60", "kernel" => "Darwin")
+      @bar_facts = Puppet::Node::Facts.new("bar", "uptime_days" => "30", "kernel" => "Linux")
+      @foo_facts.save
+      @bar_facts.save
+    end
+
+    it "should identify facts by node name" do
+      Puppet::Node::Facts.find("foo").should == @foo_facts
+    end
+
+    it "should return nil if no node instance can be found" do
+      Puppet::Node::Facts.find("non-existent node").should == nil
+    end
+  end
+
+  describe "#search" do
+    def search_request(conditions)
+      Puppet::Indirector::Request.new(:facts, :search, nil, conditions)
+    end
+
+    before :each do
+      @now = Time.now
+      @foo = Puppet::Node::Facts.new("foo", "fact1" => "value1", "fact2" => "value2", "uptime_days" => "30")
+      @bar = Puppet::Node::Facts.new("bar", "fact1" => "value1", "uptime_days" => "60")
+      @baz = Puppet::Node::Facts.new("baz", "fact1" => "value2", "fact2" => "value1", "uptime_days" => "90")
+      @bat = Puppet::Node::Facts.new("bat")
+      @foo.timestamp = @now - 3600*1
+      @bar.timestamp = @now - 3600*3
+      @baz.timestamp = @now - 3600*5
+      @bat.timestamp = @now - 3600*7
+      @foo.save
+      @bar.save
+      @baz.save
+      @bat.save
+    end
+
+    it "should return node names that match 'equal' constraints" do
+      request = search_request('facts.fact1.eq' => 'value1',
+                               'facts.fact2.eq' => 'value2')
+      terminus.search(request).should == ["foo"]
+    end
+
+    it "should return node names that match 'not equal' constraints" do
+      request = search_request('facts.fact1.ne' => 'value2')
+      terminus.search(request).should == ["bar","foo"]
+    end
+
+    it "should return node names that match strict inequality constraints" do
+      request = search_request('facts.uptime_days.gt' => '20',
+                               'facts.uptime_days.lt' => '70')
+      terminus.search(request).should == ["bar","foo"]
+    end
+
+    it "should return node names that match non-strict inequality constraints" do
+      request = search_request('facts.uptime_days.ge' => '30',
+                               'facts.uptime_days.le' => '60')
+      terminus.search(request).should == ["bar","foo"]
+    end
+
+    it "should return node names whose facts are within a given timeframe" do
+      request = search_request('meta.timestamp.ge' => @now - 3600*5,
+                               'meta.timestamp.le' => @now - 3600*1)
+      terminus.search(request).should == ["bar","baz","foo"]
+    end
+
+    it "should return node names whose facts are from a specific time" do
+      request = search_request('meta.timestamp.eq' => @now - 3600*3)
+      terminus.search(request).should == ["bar"]
+    end
+
+    it "should return node names whose facts are not from a specific time" do
+      request = search_request('meta.timestamp.ne' => @now - 3600*1)
+      terminus.search(request).should == ["bar","bat","baz"]
+    end
+
+    it "should perform strict searches on nodes by timestamp" do
+      request = search_request('meta.timestamp.gt' => @now - 3600*5,
+                               'meta.timestamp.lt' => @now - 3600*1)
+      terminus.search(request).should == ["bar"]
+    end
+
+    it "should search nodes based on both facts and timestamp values" do
+      request = search_request('facts.uptime_days.gt' => '45',
+                               'meta.timestamp.lt'    => @now - 3600*4)
+      terminus.search(request).should == ["baz"]
+    end
+  end
+end
+