puppet 3.0.0.rc5 → 3.0.0.rc7

data/spec/spec_helper.rb

@@ -48,6 +48,12 @@ RSpec.configure do |config|
 
   config.mock_with :mocha
 
+  if Puppet::Util::Platform.windows?
+    config.output_stream = $stdout
+    config.error_stream = $stderr
+    config.formatters.each { |f| f.instance_variable_set(:@output, $stdout) }
+  end
+
   config.before :all do
     Puppet::Test::TestHelper.before_all_tests()
   end

data/spec/unit/agent/locker_spec.rb

@@ -23,15 +23,21 @@ describe Puppet::Agent::Locker do
     @locker.send(:lockfile).should be_instance_of(Puppet::Util::Pidlock)
   end
 
-  it "should use puppet's :agent_pidfile' setting to determine its lockfile path" do
+  it "should use puppet's agent_catalog_run_lockfile' setting to determine its lockfile path" do
     lockfile = File.expand_path("/my/lock")
-    Puppet[:agent_pidfile] = lockfile
+    Puppet[:agent_catalog_run_lockfile] = lockfile
     lock = Puppet::Util::Pidlock.new(lockfile)
     Puppet::Util::Pidlock.expects(:new).with(lockfile).returns lock
 
     @locker.send(:lockfile)
   end
 
+  it "#lockfile_path provides the path to the lockfile" do
+    lockfile = File.expand_path("/my/lock")
+    Puppet[:agent_catalog_run_lockfile] = lockfile
+    @locker.lockfile_path.should == File.expand_path("/my/lock")
+  end
+
   it "should reuse the same lock file each time" do
     @locker.send(:lockfile).should equal(@locker.send(:lockfile))
   end

data/spec/unit/application/agent_spec.rb

@@ -70,10 +70,10 @@ describe Puppet::Application::Agent do
       @puppetd.options[:serve].should == []
     end
 
-    it "should use MD5 as default digest algorithm" do
+    it "should use SHA256 as default digest algorithm" do
       @puppetd.preinit
 
-      @puppetd.options[:digest].should == :MD5
+      @puppetd.options[:digest].should == 'SHA256'
     end
 
     it "should not fingerprint by default" do
@@ -337,9 +337,26 @@ describe Puppet::Application::Agent do
       Puppet[:node_terminus].should ==  :rest
     end
 
-    it "should tell the catalog handler to use cache" do
+    it "has an application default :catalog_cache_terminus setting of 'json'" do
+      Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:json)
+
+      @puppetd.initialize_app_defaults
+      @puppetd.setup
+    end
+
+    it "should tell the catalog cache class based on the :catalog_cache_terminus setting" do
+      Puppet[:catalog_cache_terminus] = "yaml"
       Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:yaml)
 
+      @puppetd.initialize_app_defaults
+      @puppetd.setup
+    end
+
+    it "should not set catalog cache class if :catalog_cache_terminus is explicitly nil" do
+      Puppet[:catalog_cache_terminus] = nil
+      Puppet::Resource::Catalog.indirection.expects(:cache_class=).never
+
+      @puppetd.initialize_app_defaults
       @puppetd.setup
     end
 
@@ -456,10 +473,15 @@ describe Puppet::Application::Agent do
       it "should use puppet default port" do
         Puppet[:puppetport] = 32768
 
-        Puppet::Network::Server.expects(:new).with { |args| args[:port] == 32768 }
+        Puppet::Network::Server.expects(:new).with(anything, 32768)
 
         @puppetd.setup_listen
       end
+      
+      it "should issue a warning that listen is deprecated" do
+        Puppet.expects(:warning).with() { |msg| msg =~ /kick is deprecated/ }
+        @puppetd.setup_listen
+      end
     end
 
     describe "when setting up for fingerprint" do
@@ -589,20 +611,20 @@ describe Puppet::Application::Agent do
 
       it "should fingerprint the certificate if it exists" do
         @host.expects(:certificate).returns(@cert)
-        @cert.expects(:fingerprint).with(:MD5).returns "fingerprint"
+        @cert.expects(:digest).with('MD5').returns "fingerprint"
         @puppetd.fingerprint
       end
 
       it "should fingerprint the certificate request if no certificate have been signed" do
         @host.expects(:certificate).returns(nil)
         @host.expects(:certificate_request).returns(@cert)
-        @cert.expects(:fingerprint).with(:MD5).returns "fingerprint"
+        @cert.expects(:digest).with('MD5').returns "fingerprint"
         @puppetd.fingerprint
       end
 
       it "should display the fingerprint" do
         @host.stubs(:certificate).returns(@cert)
-        @cert.stubs(:fingerprint).with(:MD5).returns("DIGEST")
+        @cert.stubs(:digest).with('MD5').returns("DIGEST")
 
         @puppetd.expects(:puts).with "DIGEST"
 

data/spec/unit/application/apply_spec.rb

@@ -103,7 +103,7 @@ describe Puppet::Application::Apply do
     end
 
     it "should set default_file_terminus to `file_server` to be local" do
-      @apply.app_defaults[:default_file_terminus].should == 'file_server'
+      @apply.app_defaults[:default_file_terminus].should == :file_server
     end
   end
 

data/spec/unit/application/device_spec.rb

@@ -219,9 +219,26 @@ describe Puppet::Application::Device do
       Puppet[:node_terminus].should ==  :rest
     end
 
-    it "should tell the catalog handler to use cache" do
+    it "has an application default :catalog_cache_terminus setting of 'json'" do
+      Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:json)
+
+      @device.initialize_app_defaults
+      @device.setup
+    end
+
+    it "should tell the catalog cache class based on the :catalog_cache_terminus setting" do
+      Puppet[:catalog_cache_terminus] = "yaml"
       Puppet::Resource::Catalog.indirection.expects(:cache_class=).with(:yaml)
 
+      @device.initialize_app_defaults
+      @device.setup
+    end
+
+    it "should not set catalog cache class if :catalog_cache_terminus is explicitly nil" do
+      Puppet[:catalog_cache_terminus] = nil
+      Puppet::Resource::Catalog.indirection.expects(:cache_class=).never
+
+      @device.initialize_app_defaults
       @device.setup
     end
 

data/spec/unit/application/face_base_spec.rb

@@ -14,6 +14,10 @@ describe Puppet::Application::FaceBase do
     app
   end
 
+  after :each do
+    app.class.clear_everything_for_tests
+  end
+
   describe "#find_global_settings_argument" do
     it "should not match --ca to --ca-location" do
       option = mock('ca option', :optparse_args => ["--ca"])
@@ -155,6 +159,16 @@ describe Puppet::Application::FaceBase do
         to raise_error OptionParser::InvalidOption, /invalid option: --bar/
     end
 
+    it "does not skip when a puppet global setting is given as one item" do
+      app.command_line.stubs(:args).returns %w{--confdir=/tmp/puppet foo}
+      expect { app.preinit; app.parse_options }.not_to raise_error
+    end
+
+    it "does not skip when a puppet global setting is given as two items" do
+      app.command_line.stubs(:args).returns %w{--confdir /tmp/puppet foo}
+      expect { app.preinit; app.parse_options }.not_to raise_error
+    end
+
     { "boolean options before" => %w{--trace foo},
       "boolean options after"  => %w{foo --trace}
     }.each do |name, args|
@@ -269,8 +283,8 @@ describe Puppet::Application::FaceBase do
 
   describe "#render" do
     before :each do
-      app.face      = Puppet::Face[:basetest, '0.0.1']
-      app.action    = app.face.get_action(:foo)
+      app.face      = Puppet::Interface.new('basetest', '0.0.1')
+      app.action    = Puppet::Interface::Action.new(app.face, :foo)
     end
 
     context "default rendering" do

data/spec/unit/application/kick_spec.rb

@@ -121,6 +121,11 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
       @kick.options.stubs(:[]).with(any_parameters)
     end
 
+    it "should issue a warning that kick is deprecated" do
+      Puppet.expects(:warning).with() { |msg| msg =~ /kick is deprecated/ }
+      @kick.setup
+    end
+
     it "should abort stating that kick is not supported on Windows" do
       Puppet.features.stubs(:microsoft_windows?).returns(true)
 
@@ -216,6 +221,9 @@ describe Puppet::Application::Kick, :if => Puppet.features.posix? do
         @kick.options.stubs(:[]).with(:ignoreschedules).returns(false)
         @kick.options.stubs(:[]).with(:foreground).returns(false)
         @kick.options.stubs(:[]).with(:debug).returns(false)
+        @kick.options.stubs(:[]).with(:verbose).returns(false) # needed when logging is initialized
+        @kick.options.stubs(:[]).with(:setdest).returns(false) # needed when logging is initialized
+         
         @kick.stubs(:print)
         @kick.preinit
         @kick.stubs(:parse_options)

data/spec/unit/application/queue_spec.rb

@@ -82,6 +82,11 @@ describe Puppet::Application::Queue, :unless => Puppet.features.microsoft_window
       lambda { @queue.setup }.should raise_error(ArgumentError)
     end
 
+    it "should issue a warning that queue is deprecated" do
+      Puppet.expects(:warning).with() { |msg| msg =~ /queue is deprecated/ }
+      @queue.setup
+    end
+
     it "should print puppet config if asked to in Puppet config" do
       Puppet.settings.stubs(:print_configs?).returns(true)
       Puppet.settings.expects(:print_configs).returns(true)

data/spec/unit/application_spec.rb

@@ -86,27 +86,20 @@ describe Puppet::Application do
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #initialize_app_defaults" do
       Puppet.features.stubs(:syslog?).returns(true)
-      Puppet[:run_mode].should == :user
 
-      expect {
-        app = TestApp.new
-        app.initialize_app_defaults
+      app = TestApp.new
+      app.initialize_app_defaults
 
-        Puppet[:run_mode].should == :master
-      }.to_not raise_error
+      Puppet.run_mode.should be_master
     end
 
     it "should sadly and frighteningly allow run_mode to change at runtime via #run" do
-      expect {
-        app = TestApp.new
-        app.run
-
-        app.class.run_mode.name.should == :master
+      app = TestApp.new
+      app.run
 
-        Puppet[:run_mode].should == :master
-
-      }.to_not raise_error
+      app.class.run_mode.name.should == :master
 
+      Puppet.run_mode.should be_master
     end
   end
 
@@ -124,16 +117,13 @@ describe Puppet::Application do
 
 
   it "should explode when an invalid run mode is set at runtime, for great victory" do
-    class InvalidRunModeTestApp < Puppet::Application
-      run_mode :abracadabra
-      def run_command
-        # no-op
-      end
-    end
-
     expect {
-      app = InvalidRunModeTestApp.new
-      app.initialize_app_defaults
+      class InvalidRunModeTestApp < Puppet::Application
+        run_mode :abracadabra
+        def run_command
+          # no-op
+        end
+      end
     }.to raise_error
   end
 

data/spec/unit/configurer/downloader_spec.rb

@@ -21,15 +21,6 @@ describe Puppet::Configurer::Downloader do
     dler.source.should == "source"
   end
 
-  it "should be able to provide a timeout value" do
-    Puppet::Configurer::Downloader.should respond_to(:timeout_interval)
-  end
-
-  it "should use the configtimeout, converted to an integer, as its timeout" do
-    Puppet[:configtimeout] = "50"
-    Puppet::Configurer::Downloader.timeout_interval.should == 50
-  end
-
   describe "when creating the file that does the downloading" do
     before do
       @dler = Puppet::Configurer::Downloader.new("foo", "path", "source")
@@ -154,8 +145,8 @@ describe Puppet::Configurer::Downloader do
       @dler.evaluate
     end
 
-    it "should set a timeout for the download" do
-      Puppet::Configurer::Downloader.expects(:timeout_interval).returns 50
+    it "should set a timeout for the download using the `configtimeout` setting" do
+      Puppet[:configtimeout] = 50
       Timeout.expects(:timeout).with(50)
 
       @dler.evaluate

data/spec/unit/configurer_spec.rb

@@ -104,6 +104,12 @@ describe Puppet::Configurer do
       @agent.run(:pluginsync => false)
     end
 
+    it "should carry on when it can't fetch it's node definition" do
+      error = Net::HTTPError.new(400, 'dummy server communication error')
+      Puppet::Node.indirection.expects(:find).raises(error)
+      @agent.run.should == 0
+    end
+
     it "should initialize a transaction report if one is not provided" do
       report = Puppet::Transaction::Report.new("apply")
       Puppet::Transaction::Report.expects(:new).returns report

data/spec/unit/face/node_spec.rb

@@ -88,7 +88,7 @@ describe Puppet::Face[:node, '0.0.1'] do
 
         it "should run in master mode" do
           subject.clean('hostname')
-          Puppet[:run_mode].should == :master
+          Puppet.run_mode.should be_master
         end
 
         it "should set node cache as yaml" do

data/spec/unit/hiera/backend/puppet_backend_spec.rb

@@ -0,0 +1,140 @@
+require 'spec_helper'
+require 'hiera/backend/puppet_backend'
+
+
+describe Hiera::Backend::Puppet_backend do
+  before do
+    Hiera.stubs(:warn)
+    Hiera.stubs(:debug)
+    Hiera::Backend.stubs(:datasources).yields([])
+    Puppet::Parser::Functions.stubs(:function).with(:include)
+
+    @mockresource = mock
+    @mockresource.stubs(:name).returns("ntp::config")
+
+    @mockscope = mock
+    @mockscope.stubs(:resource).returns(@mockresource)
+
+    @scope = Hiera::Scope.new(@mockscope)
+
+    @backend = Hiera::Backend::Puppet_backend.new
+  end
+
+  describe "#hierarchy" do
+    it "should use the configured datasource" do
+      Hiera::Config.expects("[]").with(:puppet).returns({:datasource => "rspec"})
+      Hiera::Config.expects("[]").with(:hierarchy)
+
+      ["ntp", "ntp::config"].each do |klass|
+        Hiera::Backend.expects(:parse_string).with(klass, @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns(klass)
+      end
+
+      @backend.hierarchy(@scope, nil).should == ["rspec::ntp::config", "rspec::ntp", "ntp::config::rspec", "ntp::rspec"]
+    end
+
+    it "should not include empty class names" do
+      Hiera::Config.expects("[]").with(:puppet).returns({:datasource => "rspec"})
+      Hiera::Config.expects("[]").with(:hierarchy).returns(["%{foo}", "common"])
+
+      Hiera::Backend.expects(:parse_string).with("common", @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns("common")
+      Hiera::Backend.expects(:parse_string).with("%{foo}", @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns("")
+
+      @backend.hierarchy(@scope, nil).should == ["rspec::common", "ntp::config::rspec", "ntp::rspec"]
+    end
+
+    it "should allow for an override data source" do
+      Hiera::Config.expects("[]").with(:puppet).returns({:datasource => "rspec"})
+      Hiera::Config.expects("[]").with(:hierarchy)
+
+      ["ntp", "ntp::config"].each do |klass|
+        Hiera::Backend.expects(:parse_string).with(klass, @scope, {"calling_module" => "ntp", "calling_class" => "ntp::config"}).returns(klass)
+      end
+
+      @backend.hierarchy(@scope, "override").should == ["rspec::override", "rspec::ntp::config", "rspec::ntp", "ntp::config::rspec", "ntp::rspec"]
+    end
+  end
+
+  describe "#lookup" do
+    it "should attempt to load data from unincluded classes" do
+      Hiera::Backend.expects(:parse_answer).with("rspec", @scope).returns("rspec")
+
+      catalog = mock
+      catalog.expects(:classes).returns([])
+
+      @scope.expects(:catalog).returns(catalog)
+      @scope.expects(:function_include).with(["rspec"])
+      @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec")
+
+      @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec"])
+      @backend.lookup("key", @scope, nil, nil).should == "rspec"
+    end
+
+    it "should not load loaded classes" do
+      Hiera::Backend.expects(:parse_answer).with("rspec", @scope).returns("rspec")
+      catalog = mock
+      catalog.expects(:classes).returns(["rspec"])
+      @mockscope.expects(:catalog).returns(catalog)
+      @mockscope.expects(:function_include).never
+      @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec")
+
+      @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec"])
+      @backend.lookup("key", @scope, nil, nil).should == "rspec"
+    end
+
+    it "should return the first found data" do
+      Hiera::Backend.expects(:parse_answer).with("rspec", @scope).returns("rspec")
+      catalog = mock
+      catalog.expects(:classes).returns(["rspec", "override"])
+      @mockscope.expects(:catalog).returns(catalog)
+      @mockscope.expects(:function_include).never
+      @mockscope.expects(:lookupvar).with("override::key").returns("rspec")
+      @mockscope.expects(:lookupvar).with("rspec::key").never
+
+      @backend.expects(:hierarchy).with(@scope, "override").returns(["override", "rspec"])
+      @backend.lookup("key", @scope, "override", nil).should == "rspec"
+    end
+
+    it "should return an array of found data for array searches" do
+      Hiera::Backend.expects(:parse_answer).with("rspec::key", @scope).returns("rspec::key")
+      Hiera::Backend.expects(:parse_answer).with("test::key", @scope).returns("test::key")
+      catalog = mock
+      catalog.expects(:classes).returns(["rspec", "test"])
+      @mockscope.expects(:catalog).returns(catalog)
+      @mockscope.expects(:function_include).never
+      @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec::key")
+      @mockscope.expects(:lookupvar).with("test::key").returns("test::key")
+
+      @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
+      @backend.lookup("key", @scope, nil, :array).should == ["rspec::key", "test::key"]
+    end
+
+
+    it "should return a hash of found data for hash searches" do
+      Hiera::Backend.expects(:parse_answer).with("rspec::key", @scope).returns({'rspec'=>'key'})
+      Hiera::Backend.expects(:parse_answer).with("test::key", @scope).returns({'test'=>'key'})
+      catalog = mock
+      catalog.expects(:classes).returns(["rspec", "test"])
+      @mockscope.expects(:catalog).returns(catalog)
+      @mockscope.expects(:function_include).never
+      @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec::key")
+      @mockscope.expects(:lookupvar).with("test::key").returns("test::key")
+
+      @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
+      @backend.lookup("key", @scope, nil, :hash).should == {'rspec'=>'key', 'test'=>'key'}
+    end
+
+    it "should return a merged hash of found data for hash searches" do
+      Hiera::Backend.expects(:parse_answer).with("rspec::key", @scope).returns({'rspec'=>'key', 'common'=>'rspec'})
+      Hiera::Backend.expects(:parse_answer).with("test::key", @scope).returns({'test'=>'key', 'common'=>'rspec'})
+      catalog = mock
+      catalog.expects(:classes).returns(["rspec", "test"])
+      @mockscope.expects(:catalog).returns(catalog)
+      @mockscope.expects(:function_include).never
+      @mockscope.expects(:lookupvar).with("rspec::key").returns("rspec::key")
+      @mockscope.expects(:lookupvar).with("test::key").returns("test::key")
+
+      @backend.expects(:hierarchy).with(@scope, nil).returns(["rspec", "test"])
+      @backend.lookup("key", @scope, nil, :hash).should == {'rspec'=>'key', 'common'=>'rspec', 'test'=>'key'}
+    end
+  end
+end