puppet 5.3.7-universal-darwin → 5.4.0-universal-darwin

data/spec/unit/pops/loaders/loaders_spec.rb

@@ -230,6 +230,17 @@ describe 'loaders' do
       expect(function.call({})).to eql("usee2::callee() was told 'passed value' + I am user::caller2()")
     end
 
+    it 'all other modules are visible when tasks are enabled' do
+      Puppet[:tasks] = true
+
+      env = environment_for(File.join(dependent_modules_with_metadata, 'modules'))
+      loaders = Puppet::Pops::Loaders.new(env)
+
+      moduleb_loader = loaders.private_loader_for_module('user')
+      function = moduleb_loader.load_typed(typed_name(:function, 'user::caller')).value
+      expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
+    end
+
     [ 'outside a function', 'a puppet function declared under functions', 'a puppet function declared in init.pp', 'a ruby function'].each_with_index do |from, from_idx|
       [ {:from => from, :called => 'a puppet function declared under functions', :expects => "I'm the function usee::usee_puppet()"},
         {:from => from, :called => 'a puppet function declared in init.pp', :expects => "I'm the function usee::usee_puppet_init()"},

data/spec/unit/pops/loaders/module_loaders_spec.rb

@@ -90,6 +90,49 @@ describe 'FileBased module loader' do
     expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
   end
 
+  context 'loading tasks' do
+    before(:each) do
+      Puppet[:tasks] = true
+      Puppet.push_context(:loaders => loaders)
+    end
+    after(:each) { Puppet.pop_context }
+
+    it 'can load tasks with multiple files' do
+      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => '{}'})
+
+      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
+
+      task = module_loader.load_typed(typed_name(:task, 'testmodule::foo')).value
+      expect(task.name).to eq('testmodule::foo')
+      expect(File.basename(task.executable)).to eq('foo.py')
+    end
+
+    it 'can load multiple tasks with multiple files' do
+      module_dir = dir_containing('testmodule', 'tasks' => {'foo.py' => '', 'foo.json' => '{}', 'foobar.py' => '', 'foobar.json' => '{}'})
+
+      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
+
+      foo_task = module_loader.load_typed(typed_name(:task, 'testmodule::foo')).value
+      foobar_task = module_loader.load_typed(typed_name(:task, 'testmodule::foobar')).value
+
+      expect(foo_task.name).to eq('testmodule::foo')
+      expect(File.basename(foo_task.executable)).to eq('foo.py')
+      expect(foobar_task.name).to eq('testmodule::foobar')
+      expect(File.basename(foobar_task.executable)).to eq('foobar.py')
+    end
+
+    it "won't load tasks with invalid names" do
+      module_dir = dir_containing('testmodule', 'tasks' => {'a-b.py' => '', 'foo.tar.gz' => ''})
+
+      module_loader = Puppet::Pops::Loader::ModuleLoaders.module_loader_from(static_loader, loaders, 'testmodule', module_dir)
+
+      tasks = module_loader.discover(:task)
+      expect(tasks).to be_empty
+
+      expect(module_loader.load_typed(typed_name(:task, 'testmodule::foo'))).to be_nil
+    end
+  end
+
   def typed_name(type, name)
     Puppet::Pops::Loader::TypedName.new(type, name)
   end

data/spec/unit/pops/loaders/static_loader_spec.rb

@@ -3,17 +3,22 @@ require 'puppet/pops'
 require 'puppet/loaders'
 
 describe 'the static loader' do
+  let(:loader) do
+    loader = Puppet::Pops::Loader::StaticLoader.new()
+    loader.runtime_3_init
+    loader
+  end
+
   it 'has no parent' do
-    expect(Puppet::Pops::Loader::StaticLoader.new.parent).to be(nil)
+    expect(loader.parent).to be(nil)
   end
 
   it 'identifies itself in string form' do
-    expect(Puppet::Pops::Loader::StaticLoader.new.to_s).to be_eql('(StaticLoader)')
+    expect(loader.to_s).to be_eql('(StaticLoader)')
   end
 
   it 'support the Loader API' do
     # it may produce things later, this is just to test that calls work as they should - now all lookups are nil.
-    loader = Puppet::Pops::Loader::StaticLoader.new()
     a_typed_name = typed_name(:function, 'foo')
     expect(loader[a_typed_name]).to be(nil)
     expect(loader.load_typed(a_typed_name)).to be(nil)
@@ -21,8 +26,6 @@ describe 'the static loader' do
   end
 
   context 'provides access to resource types built into puppet' do
-    let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
-
     %w{
       Augeas
       Component
@@ -82,11 +85,16 @@ describe 'the static loader' do
   end
 
   context 'provides access to app-management specific resource types built into puppet' do
+    it "such that Node is available" do
+      expect(loader.load(:type, 'node')).to be_the_type(resource_type('Node'))
+    end
+  end
 
+  context 'without init_runtime3 initialization' do
     let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
 
-    it "such that Node is available" do
-      expect(loader.load(:type, 'node')).to be_the_type(resource_type('Node'))
+    it 'does not provide access to resource types built into puppet' do
+      expect(loader.load(:type, 'file')).to be_nil
     end
   end
 

data/spec/unit/pops/model/model_spec.rb

@@ -34,4 +34,9 @@ describe Puppet::Pops::Model::Factory do
     x = Factory.literal(2) * Factory.literal(10) + Factory.literal(20)
     expect(Puppet::Pops::Model::ModelTreeDumper.new.dump(x.model)).to eq("(+ (* 2 10) 20)")
   end
+
+describe "should be describable with labels"
+  it 'describes a PlanDefinition as "Plan Definition"' do
+    expect(Puppet::Pops::Model::ModelLabelProvider.new.label(Factory.PLAN('test', [], nil))).to eq("Plan Definition")
+  end
 end

data/spec/unit/pops/parser/lexer2_spec.rb

@@ -104,6 +104,21 @@ describe 'Lexer2' do
     end
   end
 
+  context 'when --no-tasks (the default)' do
+    it "should lex a NAME from 'plan'" do
+      expect(tokens_scanned_from('plan')).to match_tokens2(:NAME)
+    end
+  end
+
+  context 'when --tasks' do
+    before(:each) { Puppet[:tasks] = true }
+    after(:each) { Puppet[:tasks] = false }
+
+    it "should lex a keyword from 'plan'" do
+      expect(tokens_scanned_from('plan')).to match_tokens2(:PLAN)
+    end
+  end
+
   # TODO: Complete with all edge cases
   [ 'A', 'A::B', '::A', '::A::B',].each do |string|
     it "should lex a CLASSREF on the form '#{string}'" do

data/spec/unit/pops/parser/locator_spec.rb

@@ -21,4 +21,24 @@ describe Puppet::Pops::Parser::Locator do
     expect(model.body.locator.extract_tree_text(model.body)).to eq('1 + 2')
   end
 
+  it 'Locator caches last offset / line' do
+    #Puppet::Pops::Parser::Locator::AbstractLocator.expects(:ary_bsearch_i).once
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string("$a\n = 1\n + 1\n").model
+    model.body.locator.expects(:ary_bsearch_i).with(anything, 2).once.returns(:special_value)
+    expect(model.body.locator.line_for_offset(2)).to eq(:special_value)
+    expect(model.body.locator.line_for_offset(2)).to eq(:special_value)
+  end
+
+  it 'Locator invalidates last offset / line cache if asked for different offset' do
+    #Puppet::Pops::Parser::Locator::AbstractLocator.expects(:ary_bsearch_i).once
+    parser = Puppet::Pops::Parser::Parser.new()
+    model = parser.parse_string("$a\n = 1\n + 1\n").model
+    model.body.locator.expects(:ary_bsearch_i).with(anything, 2).twice.returns(:first_value, :third_value)
+    model.body.locator.expects(:ary_bsearch_i).with(anything, 3).once.returns(:second_value)
+    expect(model.body.locator.line_for_offset(2)).to eq(:first_value)
+    expect(model.body.locator.line_for_offset(3)).to eq(:second_value) # invalidates cache as side effect
+    expect(model.body.locator.line_for_offset(2)).to eq(:third_value)
+  end
+
 end

data/spec/unit/pops/parser/parse_basic_expressions_spec.rb

@@ -137,6 +137,7 @@ describe "egrammar parsing basic expressions" do
   context "When parsing unfold" do
     it "$a = *[1,2]" do; expect(dump(parse("$a = *[1,2]"))).to eq("(= $a (unfold ([] 1 2)))") ; end
     it "$a = *1"     do; expect(dump(parse("$a = *1"))).to eq("(= $a (unfold 1))") ; end
+    it "$a = *[1,a => 2]" do; expect(dump(parse("$a = *[1,a => 2]"))).to eq("(= $a (unfold ([] 1 ({} (a 2)))))") ; end
   end
 
   context "When parsing Lists" do
@@ -152,6 +153,26 @@ describe "egrammar parsing basic expressions" do
       expect(dump(parse("$a = [1,2,3]"))).to eq("(= $a ([] 1 2 3))")
     end
 
+    it "$a = [1,a => 2]" do
+      expect(dump(parse("$a = [1,a => 2]"))).to eq('(= $a ([] 1 ({} (a 2))))')
+    end
+
+    it "$a = [1,a => 2, 3]" do
+      expect(dump(parse("$a = [1,a => 2, 3]"))).to eq('(= $a ([] 1 ({} (a 2)) 3))')
+    end
+
+    it "$a = [1,a => 2, b => 3]" do
+      expect(dump(parse("$a = [1,a => 2, b => 3]"))).to eq('(= $a ([] 1 ({} (a 2) (b 3))))')
+    end
+
+    it "$a = [1,a => 2, b => 3, 4]" do
+      expect(dump(parse("$a = [1,a => 2, b => 3, 4]"))).to eq('(= $a ([] 1 ({} (a 2) (b 3)) 4))')
+    end
+
+    it "$a = [{ x => y }, a => 2, b => 3, { z => p }]" do
+      expect(dump(parse("$a = [{ x => y }, a => 2, b => 3, { z => p }]"))).to eq('(= $a ([] ({} (x y)) ({} (a 2) (b 3)) ({} (z p))))')
+    end
+
     it "[...[...[]]] should create nested arrays without trouble" do
       expect(dump(parse("$a = [1,[2.0, 2.1, [2.2]],[3.0, 3.1]]"))).to eq("(= $a ([] 1 ([] 2.0 2.1 ([] 2.2)) ([] 3.0 3.1)))")
     end
@@ -202,6 +223,10 @@ describe "egrammar parsing basic expressions" do
       expect(dump(parse("$a = [1,2,3][2]"))).to eq("(= $a (slice ([] 1 2 3) 2))")
     end
 
+    it '$a = [1, 2, 3][a => 2]' do
+      expect(dump(parse('$a = [1,2,3][a => 2]'))).to eq('(= $a (slice ([] 1 2 3) ({} (a 2))))')
+    end
+
     it "$a = {'a' => 1, 'b' => 2}['b']" do
       expect(dump(parse("$a = {'a'=>1,'b' =>2}[b]"))).to eq("(= $a (slice ({} ('a' 1) ('b' 2)) b))")
     end
@@ -280,6 +305,14 @@ describe "egrammar parsing basic expressions" do
       expect(dump(parse("$a = {'a'=>1,'b'=>2} != {'a'=>1,'b'=>2}"))).to eq("(= $a (!= ({} ('a' 1) ('b' 2)) ({} ('a' 1) ('b' 2))))")
     end
 
+    it "$a = 'a' => 1" do
+      expect{parse("$a = 'a' => 1")}.to raise_error(/Syntax error at '=>'/)
+    end
+
+    it "$a = { 'a' => 'b' => 1 }" do
+      expect{parse("$a = { 'a' => 'b' => 1 }")}.to raise_error(/Syntax error at '=>'/)
+    end
+
     it "calculates the text length of an empty hash" do
       expect(parse("{}").model.body.length).to eq(2)
       expect(parse("{ }").model.body.length).to eq(3)

data/spec/unit/pops/parser/parse_calls_spec.rb

@@ -30,6 +30,10 @@ describe "egrammar parsing function calls" do
         expect(dump(parse("notice {a => 2}"))).to eq("(invoke notice ({} ('a' 2)))")
       end
 
+      it 'notice a=>2' do
+        expect{parse('notice a => 2')}.to raise_error(/Syntax error at '=>'/)
+      end
+
       it "foo(bar,)" do
         expect(dump(parse("foo(bar,)"))).to eq("(invoke foo bar)")
       end
@@ -38,6 +42,26 @@ describe "egrammar parsing function calls" do
         expect(dump(parse("foo(bar,fum,)"))).to eq("(invoke foo bar fum)")
       end
 
+      it 'foo(a=>1)' do
+        expect(dump(parse('foo(a=>1)'))).to eq('(invoke foo ({} (a 1)))')
+      end
+
+      it 'foo(a=>1, b=>2)' do
+        expect(dump(parse('foo(a=>1, b=>2)'))).to eq('(invoke foo ({} (a 1) (b 2)))')
+      end
+
+      it 'foo({a=>1, b=>2})' do
+        expect(dump(parse('foo({a=>1, b=>2})'))).to eq('(invoke foo ({} (a 1) (b 2)))')
+      end
+
+      it 'foo({a=>1}, b=>2)' do
+        expect(dump(parse('foo({a=>1}, b=>2)'))).to eq('(invoke foo ({} (a 1)) ({} (b 2)))')
+      end
+
+      it 'foo(a=>1, {b=>2})' do
+        expect(dump(parse('foo(a=>1, {b=>2})'))).to eq('(invoke foo ({} (a 1)) ({} (b 2)))')
+      end
+
       it "notice fqdn_rand(30)" do
         expect(dump(parse("notice fqdn_rand(30)"))).to eq('(invoke notice (call fqdn_rand 30))')
       end
@@ -113,6 +137,10 @@ describe "egrammar parsing function calls" do
       expect(dump(parse("notice 42.type()"))).to eq('(invoke notice (call-method (. 42 type)))')
     end
 
+    it 'notice Hash.assert_type(a => 42)' do
+      expect(dump(parse('notice Hash.assert_type(a => 42)'))).to eq('(invoke notice (call-method (. hash assert_type) ({} (a 42))))')
+    end
+
     it "notice 42.type(detailed)" do
       expect(dump(parse("notice 42.type(detailed)"))).to eq('(invoke notice (call-method (. 42 type) detailed))')
     end

data/spec/unit/pops/parser/parse_conditionals_spec.rb

@@ -114,6 +114,18 @@ describe "egrammar parsing conditionals" do
       "(= $a (? $b (:default => wat) (banana => fruit) (grape => berry)))"
       )
     end
+
+    it '1+2 ? 3 => yes' do
+      expect(dump(parse("1+2 ? 3 => yes"))).to eq(
+      "(? (+ 1 2) (3 => yes))"
+      )
+    end
+
+    it 'true and 1+2 ? 3 => yes' do
+      expect(dump(parse("true and 1+2 ? 3 => yes"))).to eq(
+      "(&& true (? (+ 1 2) (3 => yes)))"
+      )
+    end
   end
 
   context "When parsing case statements" do

data/spec/unit/pops/parser/parse_plan_spec.rb

@@ -0,0 +1,48 @@
+#! /usr/bin/env ruby
+require 'spec_helper'
+require 'puppet/pops'
+require_relative 'parser_rspec_helper'
+
+describe "egrammar parsing of 'plan'" do
+  include ParserRspecHelper
+
+  context 'with --tasks' do
+    before(:each) do
+      Puppet[:tasks] = true
+    end
+
+    it "an empty body" do
+      expect(dump(parse("plan foo { }"))).to eq("(plan foo ())")
+    end
+
+    it "a non empty body" do
+      prog = <<-EPROG
+  plan foo {
+    $a = 10
+    $b = 20
+  }
+  EPROG
+      expect(dump(parse(prog))).to eq( [
+  "(plan foo (block",
+  "  (= $a 10)",
+  "  (= $b 20)",
+  "))",
+  ].join("\n"))
+    end
+
+    it "accepts parameters" do
+      s = "plan foo($p1 = 'yo', $p2) { }"
+      expect(dump(parse(s))).to eq("(plan foo (parameters (= p1 'yo') p2) ())")
+    end
+  end
+
+  context 'with --no-tasks' do
+    before(:each) do
+      Puppet[:tasks] = false
+    end
+
+    it "the keyword 'plan' is a name" do
+      expect(dump(parse("$a = plan"))).to eq("(= $a plan)")
+    end
+  end
+end

data/spec/unit/pops/serialization/packer_spec.rb

@@ -126,6 +126,14 @@ describe "the Puppet::Pops::Serialization when using #{packer_module.name}" do
       expect(val2).to be_a(Types::PBinaryType::Binary)
       expect(val2).to eql(val)
     end
+
+    it 'URI' do
+      val = URI('http://bob:ewing@dallas.example.com:8080/oil/baron?crude=cash#leftovers')
+      write(val)
+      val2 = read
+      expect(val2).to be_a(URI)
+      expect(val2).to eql(val)
+    end
   end
 
   context 'will fail on attempts to write' do

data/spec/unit/pops/serialization/serialization_spec.rb

@@ -145,6 +145,14 @@ module Serialization
       expect(val2).to eql(val)
     end
 
+    it 'URI' do
+      val = URI('http://bob:ewing@dallas.example.com:8080/oil/baron?crude=cash#leftovers')
+      write(val)
+      val2 = read
+      expect(val2).to be_a(URI)
+      expect(val2).to eql(val)
+    end
+
     it 'Sensitive with rich data' do
       sval = Time::Timestamp.now
       val = Types::PSensitiveType::Sensitive.new(sval)
@@ -225,6 +233,28 @@ module Serialization
         expect(val2).to be_a(Types::PObjectType)
         expect(val2).to eql(val)
       end
+
+      context 'ObjectType' do
+        let(:type) do
+          Types::PObjectType.new({
+            'name' => 'MyType',
+            'type_parameters' => {
+              'x' => Types::PIntegerType::DEFAULT
+            },
+            'attributes' => {
+              'x' => Types::PIntegerType::DEFAULT
+            }
+          })
+        end
+
+        it 'with preserved parameters' do
+          val = type.create(34)._pcore_type
+          write(val)
+          val2 = read
+          expect(val2).to be_a(Types::PObjectTypeExtension)
+          expect(val2).to eql(val)
+        end
+      end
     end
 
     it 'Array of rich data' do

data/spec/unit/pops/serialization/to_from_hr_spec.rb

@@ -146,6 +146,14 @@ module Serialization
       expect(val2).to eql(val)
     end
 
+    it 'URI' do
+      val = URI('http://bob:ewing@dallas.example.com:8080/oil/baron?crude=cash#leftovers')
+      write(val)
+      val2 = read
+      expect(val2).to be_a(URI)
+      expect(val2).to eql(val)
+    end
+
     it 'Sensitive with rich data' do
       sval = Time::Timestamp.now
       val = Types::PSensitiveType::Sensitive.new(sval)
@@ -251,8 +259,31 @@ module Serialization
         expect(val2).to be_a(Types::PObjectType)
         expect(val2).to eql(val)
       end
+
+      context 'ObjectType' do
+        let(:type) do
+          Types::PObjectType.new({
+            'name' => 'MyType',
+            'type_parameters' => {
+              'x' => Types::PIntegerType::DEFAULT
+            },
+            'attributes' => {
+              'x' => Types::PIntegerType::DEFAULT
+            }
+          })
+        end
+
+        it 'with preserved parameters' do
+          val = type.create(34)._pcore_type
+          write(val)
+          val2 = read
+          expect(val2).to be_a(Types::PObjectTypeExtension)
+          expect(val2).to eql(val)
+        end
+      end
     end
 
+
     it 'Array of rich data' do
       # Sensitive omitted because it doesn't respond to ==
       val = [