puppet 4.3.2 → 4.4.0

data/spec/unit/resource/capability_finder_spec.rb

@@ -15,7 +15,7 @@ describe Puppet::Resource::CapabilityFinder do
     around(:each) do |example|
       mock_pdb = !Puppet::Util.const_defined?('Puppetdb')
       if mock_pdb
-        class Puppet::Util::Puppetdb
+        module Puppet::Util::Puppetdb
           class Http; end
         end
       end
@@ -27,11 +27,8 @@ describe Puppet::Resource::CapabilityFinder do
       end
     end
 
-    class MockResponse
-      def body
-        '[{"type": "Cap", "title": "cap", "parameters": { "host" : "ahost" }}]'
-      end
-    end
+    let(:response_body) { [{"type"=>"Cap", "title"=>"cap", "parameters"=>{"host"=>"ahost"}}] }
+    let(:response) { stub('response', :body => response_body.to_json) }
 
     def make_cap_type
       Puppet::Type.newtype :cap, :is_capability => true do
@@ -40,17 +37,33 @@ describe Puppet::Resource::CapabilityFinder do
       end
     end
 
-    it 'should call Puppet::Util::PuppetDB::Http.action' do
-      Puppet::Util::Puppetdb::Http.expects(:action).returns(MockResponse.new)
-      result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
-      expect(result['host']).to eq('ahost')
+    describe "when query_puppetdb method is available" do
+      it 'should call use the query_puppetdb method if available' do
+        Puppet::Util::Puppetdb.expects(:query_puppetdb).returns(response_body)
+        Puppet::Util::Puppetdb::Http.expects(:action).never
+
+        result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
+        expect(result['host']).to eq('ahost')
+      end
     end
 
-    it 'should use pass code_id in query to Puppet::Util::PuppetDB::Http.action' do
-      code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
-      Puppet::Util::Puppetdb::Http.expects(:action).with(regexp_matches(Regexp.new(CGI.escape('"=","code_id","' + code_id + "")))).returns(MockResponse.new)
-      result = Puppet::Resource::CapabilityFinder.find('production', code_id, Puppet::Resource.new('Cap', 'cap'))
-      expect(result['host']).to eq('ahost')
+    describe "when query_puppetdb method is unavailable" do
+      before :each do
+        Puppet::Util::Puppetdb.stubs(:respond_to?).with(:query_puppetdb).returns false
+      end
+
+      it 'should call Puppet::Util::PuppetDB::Http.action' do
+        Puppet::Util::Puppetdb::Http.expects(:action).returns(response)
+        result = Puppet::Resource::CapabilityFinder.find('production', nil, Puppet::Resource.new('Cap', 'cap'))
+        expect(result['host']).to eq('ahost')
+      end
+
+      it 'should include code_id in query' do
+        code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+        Puppet::Util::Puppetdb::Http.expects(:action).with(regexp_matches(Regexp.new(CGI.escape('"=","code_id","' + code_id + "")))).returns(response)
+        result = Puppet::Resource::CapabilityFinder.find('production', code_id, Puppet::Resource.new('Cap', 'cap'))
+        expect(result['host']).to eq('ahost')
+      end
     end
   end
 end

data/spec/unit/resource/catalog_spec.rb

@@ -91,6 +91,17 @@ describe Puppet::Resource::Catalog, "when compiling" do
     expect(catalog.code_id).to be_nil
   end
 
+  it "should include a catalog_uuid" do
+    SecureRandom.stubs(:uuid).returns ("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
+    catalog = Puppet::Resource::Catalog.new("host")
+    expect(catalog.catalog_uuid).to eq("827a74c8-cf98-44da-9ff7-18c5e4bee41e")
+  end
+
+  it "should include the current catalog_format" do
+    catalog = Puppet::Resource::Catalog.new("host")
+    expect(catalog.catalog_format).to eq(1)
+  end
+
   describe "when compiling" do
     it "should accept tags" do
       config = Puppet::Resource::Catalog.new("mynode")
@@ -268,6 +279,16 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @original.code_id = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
       expect(@original.filter.code_id).to eq(@original.code_id)
     end
+
+    it 'copies the catalog_uuid' do
+      @original.catalog_uuid = '827a74c8-cf98-44da-9ff7-18c5e4bee41e'
+      expect(@original.filter.catalog_uuid).to eq(@original.catalog_uuid)
+    end
+
+    it 'copies the catalog_format' do
+      @original.catalog_format = 42
+      expect(@original.filter.catalog_format).to eq(@original.catalog_format)
+    end
   end
 
   describe "when functioning as a resource container" do
@@ -799,7 +820,9 @@ describe Puppet::Resource::Catalog, "when converting to pson" do
 
   { :name => 'myhost',
     :version => 42,
-    :code_id => 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+    :code_id => 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe',
+    :catalog_uuid => '827a74c8-cf98-44da-9ff7-18c5e4bee41e',
+    :catalog_format => 42
   }.each do |param, value|
     it "emits a #{param} equal to #{value.inspect}" do
       @catalog.send(param.to_s + "=", value)
@@ -853,6 +876,8 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
   it "should create it with the provided name" do
     @data['version'] = 50
     @data['code_id'] = 'b59e5df0578ef411f773ee6c33d8073c50e7b8fe'
+    @data['catalog_uuid'] = '827a74c8-cf98-44da-9ff7-18c5e4bee41e'
+    @data['catalog_format'] = 42
     @data['tags'] = %w{one two}
     @data['classes'] = %w{one two}
     @data['edges'] = [Puppet::Relationship.new("File[/foo]", "File[/bar]",
@@ -867,6 +892,8 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
     expect(catalog.name).to eq('myhost')
     expect(catalog.version).to eq(@data['version'])
     expect(catalog.code_id).to eq(@data['code_id'])
+    expect(catalog.catalog_uuid).to eq(@data['catalog_uuid'])
+    expect(catalog.catalog_format).to eq(@data['catalog_format'])
     expect(catalog).to be_tagged("one")
     expect(catalog).to be_tagged("two")
 
@@ -878,6 +905,11 @@ describe Puppet::Resource::Catalog, "when converting from pson" do
     expect(catalog.edges[0].target).to eq(catalog.resource(:file, "/bar"))
   end
 
+  it "defaults the catalog_format to 0" do
+    catalog = Puppet::Resource::Catalog.from_data_hash PSON.parse @data.to_pson
+    expect(catalog.catalog_format).to eq(0)
+  end
+
   it "should fail if the source resource cannot be found" do
     @data['edges'] = [Puppet::Relationship.new("File[/missing]", "File[/bar]").to_data_hash]
     @data['resources'] = [Puppet::Resource.new(:file, "/bar").to_data_hash]

data/spec/unit/resource/type_spec.rb

@@ -240,9 +240,26 @@ describe Puppet::Resource::Type do
   end
 
   describe "when setting its parameters in the scope" do
+    let(:parser) { Puppet::Pops::Parser::Parser.new() }
+
+    def wrap3x(expression)
+      Puppet::Parser::AST::PopsBridge::Expression.new(:value => expression.current)
+    end
+
+    def parse_expression(expr_string)
+      wrap3x(parser.parse_string(expr_string))
+    end
+
+    def number_expression(number)
+      wrap3x(Puppet::Pops::Model::Factory.NUMBER(number))
+    end
+
     def variable_expression(name)
-      varexpr = Puppet::Pops::Model::Factory.QNAME(name).var().current
-      Puppet::Parser::AST::PopsBridge::Expression.new(:value => varexpr)
+      wrap3x(Puppet::Pops::Model::Factory.QNAME(name).var())
+    end
+
+    def matchref_expression(number)
+      wrap3x(Puppet::Pops::Model::Factory.NUMBER(number).var())
     end
 
     before do
@@ -272,6 +289,134 @@ describe Puppet::Resource::Type do
       expect(@scope['foo']).to eq('foobar')
     end
 
+    context 'referencing a variable to the left of the default expression' do
+      it 'is possible when the referenced variable uses a default' do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('first'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(10)
+        expect(@scope['second']).to eq(10)
+      end
+
+      it 'is possible when the referenced variable is given a value' do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('first'),
+        })
+        @resource[:first] = 2
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(2)
+        expect(@scope['second']).to eq(2)
+      end
+
+      it 'is possible when the referenced variable is an array produced by match function' do
+        @type.set_arguments({
+          :first => parse_expression("'hello'.match(/(h)(.*)/)"),
+          :second => parse_expression('$first[0]'),
+          :third => parse_expression('$first[1]')
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(['hello', 'h', 'ello'])
+        expect(@scope['second']).to eq('hello')
+        expect(@scope['third']).to eq('h')
+      end
+
+      it 'does not clobber a given value' do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('first'),
+        })
+        @resource[:first] = 2
+        @resource[:second] = 5
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(2)
+        expect(@scope['second']).to eq(5)
+      end
+    end
+
+    context 'referencing a variable to the right of the default expression' do
+      before :each do
+        @type.set_arguments({
+          :first => number_expression(10),
+          :second => variable_expression('third'),
+          :third => number_expression(20)
+        })
+      end
+
+      it 'no error is raised when no defaults are evaluated' do
+        @resource[:first] = 1
+        @resource[:second] = 2
+        @resource[:third] = 3
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(1)
+        expect(@scope['second']).to eq(2)
+        expect(@scope['third']).to eq(3)
+      end
+
+      it 'no error is raised unless the referencing default expression is evaluated' do
+        @resource[:second] = 2
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq(10)
+        expect(@scope['second']).to eq(2)
+        expect(@scope['third']).to eq(20)
+      end
+
+      it 'fails when the default expression is evaluated' do
+        @resource[:first] = 1
+        expect { @type.set_resource_parameters(@resource, @scope) }.to raise_error(Puppet::Error, 'default expression for $second tries to illegally access not yet evaluated $third')
+      end
+    end
+
+    it 'does not allow a variable to be referenced from its own default expression' do
+      @type.set_arguments({
+        :first => variable_expression('first')
+      })
+      expect { @type.set_resource_parameters(@resource, @scope) }.to raise_error(Puppet::Error, 'default expression for $first tries to illegally access not yet evaluated $first')
+    end
+
+    context 'when using match scope' do
+      it '$n evaluates to undef at the top level' do
+        @type.set_arguments({
+          :first => matchref_expression('0'),
+          :second => matchref_expression('1'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope).not_to include('first')
+        expect(@scope).not_to include('second')
+      end
+
+      it 'a match scope to the left of a parameter is not visible to it' do
+        @type.set_arguments({
+          :first => parse_expression("['hello' =~ /(h)(.*)/, $1, $2]"),
+          :second => matchref_expression('1'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq([true, 'h', 'ello'])
+        expect(@scope['second']).to be_nil
+      end
+
+      it 'match scopes nests per parameter' do
+        @type.set_arguments({
+          :first => parse_expression("['hi' =~ /(h)(.*)/, $1, if 'foo' =~ /f(oo)/ { $1 }, $1, $2]"),
+          :second => matchref_expression('0'),
+        })
+        @type.set_resource_parameters(@resource, @scope)
+
+        expect(@scope['first']).to eq([true, 'h', 'oo', 'h', 'i'])
+        expect(@scope['second']).to be_nil
+      end
+    end
+
     it "should set each of the resource's parameters as variables in the scope" do
       @type.set_arguments :foo => nil, :boo => nil
       @resource[:foo] = "bar"
@@ -432,10 +577,9 @@ describe Puppet::Resource::Type do
       @scope.expects(:newscope).with(:source => @type, :namespace => '', :resource => @resource).returns subscope
 
       elevel = 876
-      subscope.expects(:ephemeral_level).returns elevel
+      subscope.expects(:with_guarded_scope).yields
       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)
@@ -484,9 +628,7 @@ describe Puppet::Resource::Type do
     it "should evaluate the AST code if any is provided" do
       code = stub 'code'
       @type.stubs(:code).returns code
-      subscope = stub_everything("subscope", :compiler => @compiler)
-      @scope.stubs(:newscope).returns subscope
-      code.expects(:safeevaluate).with subscope
+      code.expects(:safeevaluate).with kind_of(Puppet::Parser::Scope)
 
       @type.evaluate_code(@resource)
     end

data/spec/unit/resource_spec.rb

@@ -315,7 +315,10 @@ describe Puppet::Resource do
       let(:environment_name) { "testing env" }
       let(:fact_values) { { :a => 1 } }
       let(:port) { Puppet::Parser::AST::Leaf.new(:value => '80') }
-      let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
+
+      def inject_and_set_defaults(resource, scope)
+        resource.resource_type.set_resource_parameters(resource, scope)
+      end
 
       before do
         environment.known_resource_types.add(apache)
@@ -325,82 +328,118 @@ describe Puppet::Resource do
         scope.stubs(:facts).returns(Puppet::Node::Facts.new("facts", fact_values))
       end
 
-      context "when no value is provided" do
-        let(:resource) do
-          Puppet::Parser::Resource.new("class", "apache", :scope => scope)
-        end
+      context 'with a default value expression' do
+        let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => port }) }
 
-        it "should query the data_binding terminus using a namespaced key" do
-          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
-          Puppet::DataBinding.indirection.expects(:find).with(
-            'apache::port', all_of(has_key(:environment), has_key(:variables)))
-          resource.set_default_parameters(scope)
-        end
+        context "when no value is provided" do
+          let(:resource) do
+            Puppet::Parser::Resource.new("class", "apache", :scope => scope)
+          end
 
-        it "should use the value from the data_binding terminus" do
-          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
-          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
+          it "should query the data_binding terminus using a namespaced key" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with(
+              'apache::port', all_of(has_key(:environment), has_key(:variables)))
+            inject_and_set_defaults(resource, scope)
+          end
 
-          resource.set_default_parameters(scope)
+          it "should use the value from the data_binding terminus" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
 
-          expect(resource[:port]).to eq('443')
-        end
+            inject_and_set_defaults(resource, scope)
 
-        it "should use the default value if the data_binding terminus returns nil" do
-          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
-          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns(nil)
+            expect(resource[:port]).to eq('443')
+          end
 
-          resource.set_default_parameters(scope)
+          it 'should use the default value if no value is found using the data_binding terminus' do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).throws(:no_such_key)
 
-          expect(resource[:port]).to eq('80')
-        end
+            inject_and_set_defaults(resource, scope)
 
-        it "should fail with error message about data binding on a hiera failure" do
-          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
-          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
-          expect {
-            resource.set_default_parameters(scope)
-          }.to raise_error(Puppet::Error, /Lookup of key 'apache::port' failed: Forgettabotit/)
-        end
-      end
+            expect(resource[:port]).to eq('80')
+          end
 
-      context "when a value is provided" do
-        let(:port_parameter) do
-          Puppet::Parser::Resource::Param.new(
-            { :name => 'port', :value => '8080' }
-          )
-        end
+          it 'should use the default value if an undef value is found using the data_binding terminus' do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns(nil)
 
-        let(:resource) do
-          Puppet::Parser::Resource.new("class", "apache", :scope => scope,
-            :parameters => [port_parameter])
-        end
+            inject_and_set_defaults(resource, scope)
 
-        it "should not query the data_binding terminus" do
-          Puppet::DataBinding.indirection.expects(:find).never
-          resource.set_default_parameters(scope)
-        end
+            expect(resource[:port]).to eq('80')
+          end
 
-        it "should not query the injector" do
-          compiler.injector.expects(:find).never
-          resource.set_default_parameters(scope)
+          it "should fail with error message about data binding on a hiera failure" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).raises(Puppet::DataBinding::LookupError, 'Forgettabotit')
+            expect {
+              inject_and_set_defaults(resource, scope)
+            }.to raise_error(Puppet::Error, /Lookup of key 'apache::port' failed: Forgettabotit/)
+          end
         end
 
-        it "should use the value provided" do
-          Puppet::DataBinding.indirection.expects(:find).never
-          expect(resource.set_default_parameters(scope)).to eq([])
-          expect(resource[:port]).to eq('8080')
+        context "when a value is provided" do
+          let(:port_parameter) do
+            Puppet::Parser::Resource::Param.new(
+              { :name => 'port', :value => '8080' }
+            )
+          end
+
+          let(:resource) do
+            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
+            inject_and_set_defaults(resource, scope)
+          end
+
+          it "should not query the injector" do
+            compiler.injector.expects(:find).never
+            inject_and_set_defaults(resource, scope)
+          end
+
+          it "should use the value provided" do
+            Puppet::DataBinding.indirection.expects(:find).never
+            expect(resource.set_default_parameters(scope)).to eq([])
+            expect(resource[:port]).to eq('8080')
+          end
+
+          it "should use the value from the data_binding terminus when provided value is undef" do
+            Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+            Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
+
+            rs = Puppet::Parser::Resource.new("class", "apache", :scope => scope,
+              :parameters => [Puppet::Parser::Resource::Param.new({ :name => 'port', :value => nil })])
+
+            rs.resource_type.set_resource_parameters(rs, scope)
+            expect(rs[:port]).to eq('443')
+          end
         end
+      end
 
-        it "should use the value from the data_binding terminus when provided value is undef" do
+      context 'without a default value expression' do
+        let(:apache) { Puppet::Resource::Type.new(:hostclass, 'apache', :arguments => { 'port' => nil }) }
+        let(:resource) { Puppet::Parser::Resource.new("class", "apache", :scope => scope) }
+
+        it "should use the value from the data_binding terminus" do
           Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
           Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns('443')
 
-          rs = Puppet::Parser::Resource.new("class", "apache", :scope => scope,
-            :parameters => [Puppet::Parser::Resource::Param.new({ :name => 'port', :value => nil })])
+          inject_and_set_defaults(resource, scope)
+
+          expect(resource[:port]).to eq('443')
+        end
+
+        it "should use an undef value from the data_binding terminus" do
+          Puppet::DataBinding.indirection.expects(:find).with('lookup_options', any_parameters).throws(:no_such_key)
+          Puppet::DataBinding.indirection.expects(:find).with('apache::port', any_parameters).returns(nil)
+
+          inject_and_set_defaults(resource, scope)
 
-          rs.resource_type.set_resource_parameters(rs, scope)
-          expect(rs[:port]).to eq('443')
+          expect(resource[:port]).to be_nil
         end
       end
     end