puppet 4.0.0 → 4.5.0

data/spec/unit/resource/capability_finder_spec.rb

@@ -0,0 +1,77 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require_relative '../pops/parser/parser_rspec_helper'
+require 'puppet/resource/capability_finder'
+
+describe Puppet::Resource::CapabilityFinder do
+  context 'when PuppetDB is not configured' do
+    it 'should error' do
+      Puppet::Util.expects(:const_defined?).with('Puppetdb').returns false
+      expect { Puppet::Resource::CapabilityFinder.find('production', nil, nil) }.to raise_error(/PuppetDB is not available/)
+    end
+  end
+
+  context 'when PuppetDB is configured' do
+    around(:each) do |example|
+      mock_pdb = !Puppet::Util.const_defined?('Puppetdb')
+      if mock_pdb
+        module Puppet::Util::Puppetdb
+          class Http; end
+        end
+      end
+      begin
+        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+        Puppet.override(:loaders => loaders, :current_environment => env) do
+          make_cap_type
+          example.run
+        end
+      ensure
+        Puppet::Util.send(:remove_const, 'Puppetdb') if mock_pdb
+        Puppet::Type.rmtype(:cap)
+        Puppet::Pops::Loaders.clear
+      end
+    end
+
+    let(:env) { Puppet::Node::Environment.create(:testing, []) }
+    let(:loaders) { Puppet::Pops::Loaders.new(env) }
+
+    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
+        newparam :name
+        newparam :host
+      end
+    end
+
+    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
+
+    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

@@ -86,6 +86,22 @@ describe Puppet::Resource::Catalog, "when compiling" do
     expect(@catalog.server_version).to eq(5)
   end
 
+  it "defaults code_id to nil" do
+    catalog = Puppet::Resource::Catalog.new("host")
+    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")
@@ -127,6 +143,11 @@ describe Puppet::Resource::Catalog, "when compiling" do
       config.add_class("one")
       expect(config).to be_tagged("one")
     end
+
+    it "handles resource titles with brackets" do
+      config = Puppet::Resource::Catalog.new("mynode")
+      expect(config.title_key_for_ref("Notify[[foo]bar]")).to eql(["Notify", "[foo]bar"])
+    end
   end
 
   describe "when converting to a RAL catalog" do
@@ -248,6 +269,26 @@ describe Puppet::Resource::Catalog, "when compiling" do
         r == @r1
       end.edge?(@r1,@r2)).not_to be
     end
+
+    it "copies the version" do
+      @original.version = '123'
+      expect(@original.filter.version).to eq(@original.version)
+    end
+
+    it 'copies the code_id' 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
@@ -255,6 +296,7 @@ describe Puppet::Resource::Catalog, "when compiling" do
       @catalog = Puppet::Resource::Catalog.new("host")
       @one = Puppet::Type.type(:notify).new :name => "one"
       @two = Puppet::Type.type(:notify).new :name => "two"
+      @three = Puppet::Type.type(:notify).new :name => "three"
       @dupe = Puppet::Type.type(:notify).new :name => "one"
     end
 
@@ -308,6 +350,32 @@ describe Puppet::Resource::Catalog, "when compiling" do
       expect(@catalog.resource("notify[one]", nil)).to equal(@one)
     end
 
+    it "adds resources before an existing resource" do
+      @catalog.add_resource(@one)
+      @catalog.add_resource_before(@one, @two, @three)
+
+      expect(@catalog.resources).to eq([@two, @three, @one])
+    end
+
+    it "raises if adding a resource before a resource not in the catalog" do
+      expect {
+        @catalog.add_resource_before(@one, @two)
+      }.to raise_error(ArgumentError, "Cannot add resource Notify[two] before Notify[one] because Notify[one] is not yet in the catalog")
+    end
+
+    it "adds resources after an existing resource in reverse order" do
+      @catalog.add_resource(@one)
+      @catalog.add_resource_after(@one, @two, @three)
+
+      expect(@catalog.resources).to eq([@one, @three, @two])
+    end
+
+    it "raises if adding a resource after a resource not in the catalog" do
+      expect {
+        @catalog.add_resource_after(@one, @two)
+      }.to raise_error(ArgumentError, "Cannot add resource Notify[two] after Notify[one] because Notify[one] is not yet in the catalog")
+    end
+
     describe 'with a duplicate resource' do
       def resource_at(type, name, file, line)
         resource = Puppet::Resource.new(type, name)
@@ -777,17 +845,25 @@ describe Puppet::Resource::Catalog, "when converting to pson" do
     @catalog = Puppet::Resource::Catalog.new("myhost")
   end
 
-  def pson_output_should
-    @catalog.class.expects(:from_data_hash).with { |hash| yield hash }.returns(:something)
+  { :name => 'myhost',
+    :version => 42,
+    :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)
+      pson = PSON.parse(@catalog.to_pson)
+
+      expect(pson[param.to_s]).to eq(@catalog.send(param))
+    end
   end
 
-  [:name, :version, :classes].each do |param|
-    it "should set its #{param} to the #{param} of the resource" do
-      @catalog.send(param.to_s + "=", "testing") unless @catalog.send(param)
+  it "emits an array of classes" do
+    @catalog.add_class('foo')
+    pson = PSON.parse(@catalog.to_pson)
 
-      pson_output_should { |hash| expect(hash[param.to_s]).to eq(@catalog.send(param)) }
-      Puppet::Resource::Catalog.from_data_hash PSON.parse @catalog.to_pson
-    end
+    expect(pson['classes']).to eq(['foo'])
   end
 
   it "should convert its resources to a PSON-encoded array and store it as the 'resources' data" do
@@ -826,6 +902,9 @@ 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]",
@@ -839,6 +918,9 @@ 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")
 
@@ -850,6 +932,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_collection_spec.rb

@@ -76,16 +76,18 @@ describe Puppet::Resource::TypeCollection do
     end.to raise_error(Puppet::ParseError, /cannot be redefined/)
   end
 
-  it "should remove all nodes, classes, and definitions when cleared" do
+  it "should remove all nodes, classes, definitions, and applications when cleared" do
     loader = Puppet::Resource::TypeCollection.new(environment)
     loader.add Puppet::Resource::Type.new(:hostclass, "class")
     loader.add Puppet::Resource::Type.new(:definition, "define")
     loader.add Puppet::Resource::Type.new(:node, "node")
+    loader.add Puppet::Resource::Type.new(:application, "application")
 
     loader.clear
     expect(loader.hostclass("class")).to be_nil
     expect(loader.definition("define")).to be_nil
     expect(loader.node("node")).to be_nil
+    expect(loader.node("application")).to be_nil
   end
 
   describe "when looking up names" do
@@ -153,7 +155,8 @@ describe Puppet::Resource::TypeCollection do
     end
   end
 
-  %w{hostclass node definition}.each do |data|
+  KINDS = %w{hostclass node definition application}
+  KINDS.each do |data|
     describe "behavior of add for #{data}" do
 
       it "should return the added #{data}" do
@@ -175,6 +178,24 @@ describe Puppet::Resource::TypeCollection do
       it "should return nil when asked for a #{data} that has not been added" do
         expect(Puppet::Resource::TypeCollection.new(environment).send(data, "foo")).to be_nil
       end
+
+      if data != "node"
+        it "should fail if an application with the same name is added" do
+          loader = Puppet::Resource::TypeCollection.new(environment)
+          instance = Puppet::Resource::Type.new(data, "foo")
+          application = Puppet::Resource::Type.new(:application, "foo")
+          loader.add(instance)
+          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
+        end
+
+        it "should fail if there is an application with the same name" do
+          loader = Puppet::Resource::TypeCollection.new(environment)
+          application = Puppet::Resource::Type.new(:application, "foo")
+          instance = Puppet::Resource::Type.new(data, "foo")
+          loader.add(instance)
+          expect { loader.add(application) }.to raise_error(Puppet::ParseError, /redefine/)
+        end
+      end
     end
   end
 

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
@@ -766,7 +908,7 @@ describe Puppet::Resource::Type do
       source = Puppet::Resource::Type.new(:hostclass, "foo", :code => scode)
 
       dest.merge(source)
-      expect(dest.code.children.collect { |l| l.children[0].value }).to eq(%w{dest source})
+      expect(dest.code.children.map { |c| c.value }).to eq(%w{dest source})
     end
   end
 end