puppet 3.2.4 → 3.3.0.rc2

data/spec/unit/resource/type_spec.rb

@@ -80,7 +80,7 @@ describe Puppet::Resource::Type do
       lambda { Puppet::Resource::Type.new(:node, /foo/) }.should_not raise_error
     end
 
-    it "should allow a AST::HostName instance as its name" do
+    it "should allow an AST::HostName instance as its name" do
       regex = Puppet::Parser::AST::Regex.new(:value => /foo/)
       name = Puppet::Parser::AST::HostName.new(:value => regex)
       lambda { Puppet::Resource::Type.new(:node, name) }.should_not raise_error
@@ -134,6 +134,10 @@ describe Puppet::Resource::Type do
         Puppet::Resource::Type.new(:node, /\w/).match("foo").should be_true
       end
 
+      it "should return true when its regex matches the provided name" do
+        Puppet::Resource::Type.new(:node, /\w/).match("foo").should be_true
+      end
+
       it "should return false when its regex does not match the provided name" do
         (!!Puppet::Resource::Type.new(:node, /\d/).match("foo")).should be_false
       end
@@ -396,13 +400,29 @@ describe Puppet::Resource::Type do
       @resource.environment.known_resource_types.add @type
     end
 
-    it "should add hostclass names to the classes list" do
+    it "should add node regex captures to its scope" do
+      @type = Puppet::Resource::Type.new(:node, /f(\w)o(.*)$/)
+      match = @type.match('foo')
+
+      code = stub 'code'
+      @type.stubs(:code).returns code
+
+      subscope = stub 'subscope', :compiler => @compiler
+      @scope.expects(:newscope).with(:source => @type, :namespace => '', :resource => @resource).returns subscope
+
+      elevel = 876
+      subscope.expects(:ephemeral_level).returns elevel
+      subscope.expects(:ephemeral_from).with(match, nil, nil).returns subscope
+      code.expects(:safeevaluate).with(subscope)
+      subscope.expects(:unset_ephemeral_var).with(elevel)
+
+      # Just to keep the stub quiet about intermediate calls
+      @type.expects(:set_resource_parameters).with(@resource, subscope)
+
       @type.evaluate_code(@resource)
-      @compiler.catalog.classes.should be_include("foo")
     end
 
-    it "should add node names to the classes list" do
-      @type = Puppet::Resource::Type.new(:node, "foo")
+    it "should add hostclass names to the classes list" do
       @type.evaluate_code(@resource)
       @compiler.catalog.classes.should be_include("foo")
     end

data/spec/unit/resource_spec.rb

@@ -267,42 +267,45 @@ describe Puppet::Resource do
   end
 
   describe "when setting default parameters" do
-    before do
-      @scope = mock "Scope"
-      @scope.stubs(:source).returns(nil)
+    let(:foo_node) { Puppet::Node.new('foo') }
+    let(:compiler) { Puppet::Parser::Compiler.new(foo_node) }
+    let(:scope)    { Puppet::Parser::Scope.new(compiler) }
+
+    def ast_string(value)
+      Puppet::Parser::AST::String.new({:value => value})
     end
 
     it "should fail when asked to set default values and it is not a parser resource" do
       Puppet::Node::Environment.new.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => Puppet::Parser::AST::String.new(:value => "default")})
+      Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("default")})
       )
       resource = Puppet::Resource.new("default_param", "name")
-      lambda { resource.set_default_parameters(@scope) }.should raise_error(Puppet::DevError)
+      lambda { resource.set_default_parameters(scope) }.should raise_error(Puppet::DevError)
     end
 
     it "should evaluate and set any default values when no value is provided" do
       Puppet::Node::Environment.new.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => Puppet::Parser::AST::String.new(:value => "a_default_value")})
+        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("a_default_value")})
       )
-      resource = Puppet::Parser::Resource.new("default_param", "name", :scope => Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))))
-      resource.set_default_parameters(@scope)
+      resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
+      resource.set_default_parameters(scope)
       resource["a"].should == "a_default_value"
     end
 
     it "should skip attributes with no default value" do
       Puppet::Node::Environment.new.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "no_default_param", :arguments => {"a" => Puppet::Parser::AST::String.new(:value => "a_default_value")})
+        Puppet::Resource::Type.new(:definition, "no_default_param", :arguments => {"a" => ast_string("a_default_value")})
       )
-      resource = Puppet::Parser::Resource.new("no_default_param", "name", :scope => Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))))
-      lambda { resource.set_default_parameters(@scope) }.should_not raise_error
+      resource = Puppet::Parser::Resource.new("no_default_param", "name", :scope => scope)
+      lambda { resource.set_default_parameters(scope) }.should_not raise_error
     end
 
     it "should return the list of default parameters set" do
       Puppet::Node::Environment.new.known_resource_types.add(
-        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => Puppet::Parser::AST::String.new(:value => "a_default_value")})
+        Puppet::Resource::Type.new(:definition, "default_param", :arguments => {"a" => ast_string("a_default_value")})
       )
-      resource = Puppet::Parser::Resource.new("default_param", "name", :scope => Puppet::Parser::Scope.new(Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))))
-      resource.set_default_parameters(@scope).should == ["a"]
+      resource = Puppet::Parser::Resource.new("default_param", "name", :scope => scope)
+      resource.set_default_parameters(scope).should == ["a"]
     end
 
     describe "when the resource type is :hostclass" do
@@ -315,26 +318,52 @@ describe Puppet::Resource do
         environment = Puppet::Node::Environment.new(environment_name)
         environment.known_resource_types.add(apache)
 
-        @scope.stubs(:host).returns('host')
-        @scope.stubs(:environment).returns(Puppet::Node::Environment.new(environment_name))
-        @scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
+        scope.stubs(:host).returns('host')
+        scope.stubs(:environment).returns(Puppet::Node::Environment.new(environment_name))
+        scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
       end
 
       context "when no value is provided" do
+        before(:each) do
+          Puppet[:binder] = true
+        end
+
         let(:resource) do
-          Puppet::Parser::Resource.new("class", "apache", :scope => @scope)
+          Puppet::Parser::Resource.new("class", "apache", :scope => scope)
         end
 
         it "should query the data_binding terminus using a namespaced key" do
           Puppet::DataBinding.indirection.expects(:find).with(
             'apache::port', all_of(has_key(:environment), has_key(:variables)))
-          resource.set_default_parameters(@scope)
+          resource.set_default_parameters(scope)
+        end
+
+        it "should query the injector using a namespaced key" do
+          compiler.injector.expects(:lookup).with(scope, 'apache::port')
+          resource.set_default_parameters(scope)
         end
 
         it "should use the value from the data_binding terminus" do
           Puppet::DataBinding.indirection.expects(:find).returns('443')
 
-          resource.set_default_parameters(@scope)
+          resource.set_default_parameters(scope)
+
+          resource[:port].should == '443'
+        end
+
+        it "should use the value from the injector" do
+          compiler.injector.expects(:lookup).with(scope, 'apache::port').returns('443')
+
+          resource.set_default_parameters(scope)
+
+          resource[:port].should == '443'
+        end
+
+        it "should not call the DataBinding terminus when injector produces a value" do
+          compiler.injector.expects(:lookup).with(scope, 'apache::port').returns('443')
+          Puppet::DataBinding.indirection.expects(:find).never()
+
+          resource.set_default_parameters(scope)
 
           resource[:port].should == '443'
         end
@@ -342,7 +371,15 @@ describe Puppet::Resource do
         it "should use the default value if the data_binding terminus returns nil" do
           Puppet::DataBinding.indirection.expects(:find).returns(nil)
 
-          resource.set_default_parameters(@scope)
+          resource.set_default_parameters(scope)
+
+          resource[:port].should == '80'
+        end
+
+        it "should use the default value if the injector returns nil" do
+          compiler.injector.expects(:lookup).returns(nil)
+
+          resource.set_default_parameters(scope)
 
           resource[:port].should == '80'
         end
@@ -356,18 +393,25 @@ describe Puppet::Resource do
         end
 
         let(:resource) do
-          Puppet::Parser::Resource.new("class", "apache", :scope => @scope,
+          Puppet::Parser::Resource.new("class", "apache", :scope => scope,
             :parameters => [port_parameter])
         end
 
         it "should not query the data_binding terminus" do
           Puppet::DataBinding.indirection.expects(:find).never
-          resource.set_default_parameters(@scope)
+          resource.set_default_parameters(scope)
+        end
+
+        it "should not query the injector" do
+          # enable the injector
+          Puppet[:binder] = true
+          compiler.injector.expects(:find).never
+          resource.set_default_parameters(scope)
         end
 
         it "should use the value provided" do
           Puppet::DataBinding.indirection.expects(:find).never
-          resource.set_default_parameters(@scope).should == []
+          resource.set_default_parameters(scope).should == []
           resource[:port].should == '8080'
         end
       end

data/spec/unit/run_spec.rb

@@ -155,5 +155,21 @@ describe Puppet::Run do
       run.background.should be_true
       run.status.should == 'success'
     end
+
+    it "should round trip through pson" do
+      run = Puppet::Run.new(
+        :tags => ['a', 'b', 'c'],
+        :ignoreschedules => true,
+        :pluginsync => false,
+        :background => true
+      )
+      run.instance_variable_set(:@status, true)
+
+      tripped = Puppet::Run.convert_from(:pson, run.render(:pson))
+
+      tripped.options.should == run.options
+      tripped.status.should == run.status
+      tripped.background.should == run.background
+    end
   end
 end

data/spec/unit/scheduler/scheduler_spec.rb

@@ -34,14 +34,15 @@ describe Puppet::Scheduler::Scheduler do
     job
   end
 
+  let(:scheduler) { Puppet::Scheduler::Scheduler.new(timer) }
+
   it "uses the minimum interval" do
     later_job = one_time_job(7)
     earlier_job = one_time_job(2)
-    scheduler = Puppet::Scheduler::Scheduler.new([later_job, earlier_job], timer)
     later_job.last_run = now
     earlier_job.last_run = now
 
-    scheduler.run_loop
+    scheduler.run_loop([later_job, earlier_job])
 
     timer.wait_for_calls.should == [2, 5]
   end
@@ -50,9 +51,8 @@ describe Puppet::Scheduler::Scheduler do
     enabled = one_time_job(7)
     enabled.last_run = now
     disabled = disabled_job(2)
-    scheduler = Puppet::Scheduler::Scheduler.new([enabled, disabled], timer)
 
-    scheduler.run_loop
+    scheduler.run_loop([enabled, disabled])
 
     timer.wait_for_calls.should == [7]
   end
@@ -60,46 +60,35 @@ describe Puppet::Scheduler::Scheduler do
   it "asks the timer to wait for the job interval" do
     job = one_time_job(5)
     job.last_run = now
-    scheduler = Puppet::Scheduler::Scheduler.new([job], timer)
 
-    scheduler.run_loop
+    scheduler.run_loop([job])
 
     timer.wait_for_calls.should == [5]
   end
 
   it "does not run when there are no jobs" do
-    timer = mock 'no run timer'
-    scheduler = Puppet::Scheduler::Scheduler.new([], timer)
-
-    timer.stubs(:now).returns(now)
-    timer.expects(:wait_for).never
+    scheduler.run_loop([])
 
-    scheduler.run_loop
+    timer.wait_for_calls.should be_empty
   end
 
   it "does not run when there are only disabled jobs" do
-    timer = mock 'no run timer'
     disabled_job = Puppet::Scheduler::Job.new(0)
-    scheduler = Puppet::Scheduler::Scheduler.new([disabled_job], timer)
-
     disabled_job.disable
-    timer.stubs(:now).returns(now)
-    timer.expects(:wait_for).never
 
-    scheduler.run_loop
+    scheduler.run_loop([disabled_job])
+
+    timer.wait_for_calls.should be_empty
   end
 
   it "stops running when there are no more enabled jobs" do
-    timer = mock 'run once timer'
     disabling_job = Puppet::Scheduler::Job.new(0) do |j|
       j.disable
     end
-    scheduler = Puppet::Scheduler::Scheduler.new([disabling_job], timer)
 
-    timer.stubs(:now).returns(now)
-    timer.expects(:wait_for).once
+    scheduler.run_loop([disabling_job])
 
-    scheduler.run_loop
+    timer.wait_for_calls.size.should == 1
   end
 
   it "marks the start of the run loop" do
@@ -107,8 +96,7 @@ describe Puppet::Scheduler::Scheduler do
 
     disabled_job.disable
 
-    scheduler = Puppet::Scheduler::Scheduler.new([disabled_job], timer)
-    scheduler.run_loop
+    scheduler.run_loop([disabled_job])
 
     disabled_job.start_time.should == now
   end
@@ -121,8 +109,7 @@ describe Puppet::Scheduler::Scheduler do
       job.disable if countdown == 0
     end
 
-    scheduler = Puppet::Scheduler::Scheduler.new([slow_job], timer)
-    scheduler.run_loop
+    scheduler.run_loop([slow_job])
 
     timer.wait_for_calls.should == [0, 3, 7, 3]
   end

data/spec/unit/semver_spec.rb

@@ -2,6 +2,11 @@ require 'spec_helper'
 require 'semver'
 
 describe SemVer do
+
+  describe 'MAX should be +Infinity' do
+    SemVer::MAX.major.infinite?.should == 1
+  end
+
   describe '::valid?' do
     it 'should validate basic version strings' do
       %w[ 0.0.0 999.999.999 v0.0.0 v999.999.999 ].each do |vstring|

data/spec/unit/settings/enum_setting_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+require 'puppet/settings'
+
+describe Puppet::Settings::EnumSetting do
+  it "allows a configured value" do
+    setting = enum_setting_allowing("allowed")
+
+    expect(setting.munge("allowed")).to eq("allowed")
+  end
+
+  it "disallows a value that is not configured" do
+    setting = enum_setting_allowing("allowed", "also allowed")
+
+    expect do
+      setting.munge("disallowed")
+    end.to raise_error(Puppet::Settings::ValidationError,
+                       "Invalid value 'disallowed' for parameter testing. Allowed values are 'allowed', 'also allowed'")
+  end
+
+  def enum_setting_allowing(*values)
+    Puppet::Settings::EnumSetting.new(:settings => mock('settings'),
+                                      :name => "testing",
+                                      :desc => "description of testing",
+                                      :values => values)
+  end
+end

data/spec/unit/settings_spec.rb

@@ -266,7 +266,7 @@ describe Puppet::Settings do
       @settings[:myval] = "12"
       @settings.set_by_cli?(:myval).should be_false
     end
-    
+
     describe "setbycli" do
       it "should generate a deprecation warning" do
         Puppet.expects(:deprecation_warning)
@@ -289,11 +289,17 @@ describe Puppet::Settings do
       @settings.define_settings :mysection,
           :one => { :default => "whah", :desc => "yay" },
           :two => { :default => "$one yay", :desc => "bah" }
+      @settings.expects(:unsafe_flush_cache)
       @settings[:two].should == "whah yay"
       @settings.handlearg("--one", "else")
       @settings[:two].should == "else yay"
     end
 
+    it "should clear the cache when the preferred_run_mode is changed" do
+      @settings.expects(:flush_cache)
+      @settings.preferred_run_mode = :master
+    end
+
     it "should not clear other values when setting getopt-specific values" do
       @settings[:myval] = "yay"
       @settings.handlearg("--no-bool", "")
@@ -477,7 +483,8 @@ describe Puppet::Settings do
           :one    => { :default => "ONE", :desc => "a" },
           :two    => { :default => "$one TWO", :desc => "b"},
           :three  => { :default => "$one $two THREE", :desc => "c"},
-          :four   => { :default => "$two $three FOUR", :desc => "d"}
+          :four   => { :default => "$two $three FOUR", :desc => "d"},
+          :five   => { :default => nil, :desc => "e" }
       FileTest.stubs(:exist?).returns true
     end
 
@@ -535,6 +542,20 @@ describe Puppet::Settings do
       @settings[:two].should == "one TWO"
     end
 
+    describe "caching values that evaluate to false" do
+      it "caches nil" do
+        @settings.expects(:convert).once.returns nil
+        @settings[:five].should be_nil
+        @settings[:five].should be_nil
+      end
+
+      it "caches false" do
+        @settings.expects(:convert).once.returns false
+        @settings[:five].should == false
+        @settings[:five].should == false
+      end
+    end
+
     it "should not cache values such that information from one environment is returned for another environment" do
       text = "[env1]\none = oneval\n[env2]\none = twoval\n"
       @settings.stubs(:read_file).returns(text)
@@ -984,65 +1005,53 @@ describe Puppet::Settings do
       @settings.stubs(:user_config_file).returns(@userconfig)
     end
 
-    it "should use a LoadedFile instance to determine if the file has changed" do
-      file = mock 'file'
-      Puppet::Util::LoadedFile.expects(:new).with(@file).returns file
-
-      file.expects(:changed?)
-
-      @settings.stubs(:parse)
-      @settings.reparse_config_files
-    end
-
-    it "should not create the LoadedFile instance and should not parse if the file does not exist" do
+    it "does not create the WatchedFile instance and should not parse if the file does not exist" do
       FileTest.expects(:exist?).with(@file).returns false
-      Puppet::Util::LoadedFile.expects(:new).never
+      Puppet::Util::WatchedFile.expects(:new).never
 
       @settings.expects(:parse_config_files).never
 
       @settings.reparse_config_files
     end
 
-    it "should not reparse if the file has not changed" do
-      file = mock 'file'
-      Puppet::Util::LoadedFile.expects(:new).with(@file).returns file
+    context "and watched file exists" do
+      before do
+        @watched_file = Puppet::Util::WatchedFile.new(@file)
+        Puppet::Util::WatchedFile.expects(:new).with(@file).returns @watched_file
+      end
 
-      file.expects(:changed?).returns false
+      it "uses a WatchedFile instance to determine if the file has changed" do
+        @watched_file.expects(:changed?)
 
-      @settings.expects(:parse_config_files).never
+        @settings.reparse_config_files
+      end
 
-      @settings.reparse_config_files
-    end
+      it "does not reparse if the file has not changed" do
+        @watched_file.expects(:changed?).returns false
 
-    it "should reparse if the file has changed" do
-      file = stub 'file', :file => @file
-      Puppet::Util::LoadedFile.expects(:new).with(@file).returns file
+        @settings.expects(:parse_config_files).never
 
-      file.expects(:changed?).returns true
+        @settings.reparse_config_files
+      end
 
-      @settings.expects(:parse_config_files)
+      it "reparses if the file has changed" do
+        @watched_file.expects(:changed?).returns true
 
-      @settings.reparse_config_files
-    end
+        @settings.expects(:unsafe_parse).with(@file)
 
-    it "should replace in-memory values with on-file values" do
-      # Init the value
-      text = "[main]\none = disk-init\n"
-      file = mock 'file'
-      file.stubs(:changed?).returns(true)
-      file.stubs(:file).returns(@file)
-      @settings[:one] = "init"
-      @settings.files = [file]
+        @settings.reparse_config_files
+      end
 
-      # Now replace the value
-      text = "[main]\none = disk-replace\n"
+      it "replaces in-memory values with on-file values" do
+        @watched_file.stubs(:changed?).returns(true)
+        @settings[:one] = "init"
 
-      # This is kinda ridiculous - the reason it parses twice is that
-      # it goes to parse again when we ask for the value, because the
-      # mock always says it should get reparsed.
-      @settings.stubs(:read_file).returns(text)
-      @settings.reparse_config_files
-      @settings[:one].should == "disk-replace"
+        # Now replace the value
+        text = "[main]\none = disk-replace\n"
+        @settings.stubs(:read_file).returns(text)
+        @settings.reparse_config_files
+        @settings[:one].should == "disk-replace"
+      end
     end
 
     it "should retain parameters set by cli when configuration files are reparsed" do