puppet 4.4.2 → 4.5.0

data/spec/unit/parser/scope_spec.rb

@@ -324,6 +324,51 @@ describe Puppet::Parser::Scope do
         expect { @scope['module_name'] }.to_not raise_error
       end
     end
+
+    context "and strict_variables is false and --strict=off" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :off
+      end
+
+      it "should not error when unknown variable is looked up and produce nil" do
+        expect(@scope['john_doe']).to be_nil
+      end
+
+      it "should not error when unknown qualified variable is looked up and produce nil" do
+        expect(@scope['nowhere::john_doe']).to be_nil
+      end
+    end
+
+    context "and strict_variables is false and --strict=warning" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :warning
+      end
+
+      it "should not error when unknown variable is looked up" do
+        expect(@scope['john_doe']).to be_nil
+      end
+
+      it "should not error when unknown qualified variable is looked up" do
+        expect(@scope['nowhere::john_doe']).to be_nil
+      end
+    end
+
+    context "and strict_variables is false and --strict=error" do
+      before(:each) do
+        Puppet[:strict_variables] = false
+        Puppet[:strict] = :error
+      end
+
+      it "should raise error when unknown variable is looked up" do
+        expect { @scope['john_doe'] }.to raise_error(/Undefined variable/)
+      end
+
+      it "should not throw a symbol when unknown qualified variable is looked up" do
+        expect { @scope['nowhere::john_doe'] }.to raise_error(/Undefined variable/)
+      end
+    end
   end
 
   describe "when variables are set with append=true" do

data/spec/unit/pops/evaluator/access_ops_spec.rb

@@ -166,6 +166,11 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     # Hash Type
     #
+    it 'produces a Hash[0, 0] from the expression Hash[0, 0]' do
+      expr = fqr('Hash')[0, 0]
+      expect(evaluate(expr)).to be_the_type(types.hash_of(types.default, types.default, types.range(0, 0)))
+    end
+
     it 'produces a Hash[Scalar,String] from the expression Hash[Scalar, String]' do
       expr = fqr('Hash')[fqr('Scalar'), fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.hash_of(types.string, types.scalar))
@@ -192,6 +197,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl/AccessOperator' do
 
     # Array Type
     #
+    it 'produces an Array[0, 0] from the expression Array[0, 0]' do
+      expr = fqr('Array')[0, 0]
+      expect(evaluate(expr)).to be_the_type(types.array_of(types.default, types.range(0, 0)))
+
+      # arguments are flattened
+      expr = fqr('Array')[[fqr('String')]]
+      expect(evaluate(expr)).to be_the_type(types.array_of(types.string))
+    end
+
     it 'produces an Array[String] from the expression Array[String]' do
       expr = fqr('Array')[fqr('String')]
       expect(evaluate(expr)).to be_the_type(types.array_of(types.string))

data/spec/unit/pops/evaluator/evaluating_parser_spec.rb

@@ -57,7 +57,15 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         it "should parse and evaluate the expression '#{source}' to #{result}" do
           expect(parser.evaluate_string(scope, source, __FILE__)).to eq(result)
         end
-      end
+    end
+
+    it 'should error when it encounters an unknown resource' do
+      expect {parser.evaluate_string(scope, '$a = SantaClause', __FILE__)}.to raise_error(/Resource type not found: SantaClause/)
+    end
+
+    it 'should error when it encounters an unknown resource with a parameter' do
+      expect {parser.evaluate_string(scope, '$b = ToothFairy[emea]', __FILE__)}.to raise_error(/Resource type not found: ToothFairy/)
+    end
   end
 
   context "When the evaluator evaluates Lists and Hashes" do
@@ -253,9 +261,9 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
       "xxx in bananas"                => false,
       "/ana/ in bananas"              => true,
       "/xxx/ in bananas"              => false,
-      "ANA in bananas"                => false, # ANA is a type, not a String
+      "FILE in profiler"              => false, # FILE is a type, not a String
+      "'FILE' in profiler"            => true,
       "String[1] in bananas"          => false, # Philosophically true though :-)
-      "'ANA' in bananas"              => true,
       "ana in 'BANANAS'"              => true,
       "/ana/ in 'BANANAS'"            => false,
       "/ANA/ in 'BANANAS'"            => true,
@@ -307,13 +315,13 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
 
     {
       'Any'  => ['NotUndef', 'Data', 'Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Collection',
-                    'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File', 'NotYetKnownResourceType'],
+                    'Array', 'Hash', 'CatalogEntry', 'Resource', 'Class', 'Undef', 'File' ],
 
       # Note, Data > Collection is false (so not included)
       'Data'    => ['Scalar', 'Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern', 'Array', 'Hash',],
       'Scalar' => ['Numeric', 'Integer', 'Float', 'Boolean', 'String', 'Pattern'],
       'Numeric' => ['Integer', 'Float'],
-      'CatalogEntry' => ['Class', 'Resource', 'File', 'NotYetKnownResourceType'],
+      'CatalogEntry' => ['Class', 'Resource', 'File'],
       'Integer[1,10]' => ['Integer[2,3]'],
     }.each do |general, specials|
       specials.each do |special |

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

@@ -46,7 +46,98 @@ describe 'the static loader' do
     end
   end
 
+  context 'provides access to resource types built into puppet' do
+    let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
+
+    %w{
+      Auegas
+      Component
+      Computer
+      Cron
+      Exec
+      File
+      Filebucket
+      Group
+      Host
+      Interface
+      K5login
+      Macauthorization
+      Mailalias
+      Maillist
+      Mcx
+      Mount
+      Nagios_command
+      Nagios_contact
+      Nagios_contactgroup
+      Nagios_host
+      Nagios_hostdependency
+      Nagios_hostescalation
+      Nagios_hostescalation
+      Nagios_hostgroup
+      Nagios_service
+      Nagios_servicedependency
+      Nagios_serviceescalation
+      Nagios_serviceextinfo
+      Nagios_servicegroup
+      Nagios_timeperiod
+      Notify
+      Package
+      Resources
+      Router
+      Schedule
+      Scheduled_task
+      Selboolean
+      Selmodule
+      Service
+      Ssh_authorized_key
+      Sshkey
+      Stage
+      Tidy
+      User
+      Vlan
+      Whit
+      Yumrepo
+      Zfs
+      Zone
+      Zpool
+    }.each do |name |
+      it "such that #{name} is available" do
+        expect(loader.load(:type, name.downcase)).to be_the_type(resource_type(name))
+      end
+    end
+  end
+
+  context 'provides access to app-management specific resource types built into puppet' do
+    before(:each) { Puppet[:app_management] = true }
+    after(:each) { Puppet[:app_management] = false }
+
+    let(:loader) { loader = Puppet::Pops::Loader::StaticLoader.new() }
+
+    %w{Node}.each do |name|
+      it "such that #{name} is avaiable" do
+        expect(loader.load(:type, name.downcase)).to be_the_type(resource_type(name))
+      end
+    end
+  end
+
   def typed_name(type, name)
     Puppet::Pops::Loader::Loader::TypedName.new(type, name)
   end
-end
+
+  def resource_type(name)
+    Puppet::Pops::Types::TypeFactory.resource(name)
+  end
+
+  matcher :be_the_type do |type|
+    calc = Puppet::Pops::Types::TypeCalculator.new
+
+    match do |actual|
+      calc.assignable?(actual, type) && calc.assignable?(type, actual)
+    end
+
+    failure_message do |actual|
+      "expected #{type.to_s}, but was #{actual.to_s}"
+    end
+  end
+
+end

data/spec/unit/{data_providers/hiera_interpolation_spec.rb → pops/lookup/interpolation_spec.rb}

@@ -4,14 +4,15 @@ require 'puppet'
 require 'puppet/data_providers/hiera_config'
 require 'puppet/data_providers/hiera_interpolate'
 
-describe 'Puppet::DataProviders::HieraInterpolate' do
+module Puppet::Pops
+describe 'Puppet::Pops::Lookup::Interpolation' do
 
-  let(:interpolator) { Class.new { include Puppet::DataProviders::HieraInterpolate }.new }
+  let(:interpolator) { Class.new { include Lookup::Interpolation }.new }
   let(:scope) { {} }
-  let(:lookup_invocation) { Puppet::Pops::Lookup::Invocation.new(scope, {}, {}, nil) }
+  let(:lookup_invocation) { Lookup::Invocation.new(scope, {}, {}, nil) }
 
   def expect_lookup(*keys)
-    keys.each { |key| Puppet::Pops::Lookup.expects(:lookup).with(key, nil, '', true, nil, lookup_invocation).returns(data[key]) }
+    keys.each { |key| Lookup.expects(:lookup).with(key, nil, '', true, nil, lookup_invocation).returns(data[key]) }
   end
 
   context 'when interpolating nested data' do
@@ -221,7 +222,7 @@ describe 'Puppet::DataProviders::HieraInterpolate' do
 
     it 'should not find a subkey that is matched within a string' do
       expect_lookup('key')
-      expect{ interpolator.interpolate('%{hiera("key.subkey")}', lookup_invocation, true) }.to raise_error(/Got String when a hash-like object was expected to enable lookup using key 'subkey'/)
+      expect{ interpolator.interpolate('%{hiera("key.subkey")}', lookup_invocation, true) }.to raise_error(/Got String when a hash-like object was expected to access value using 'subkey' from key 'key.subkey'/)
     end
   end
 
@@ -309,3 +310,4 @@ describe 'Puppet::DataProviders::HieraInterpolate' do
     end
   end
 end
+end

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

@@ -2,7 +2,6 @@ require 'spec_helper'
 require 'matchers/match_tokens2'
 require 'puppet/pops'
 require 'puppet/pops/parser/lexer2'
-require_relative './parser_rspec_helper'
 
 module EgrammarLexer2Spec
   def tokens_scanned_from(s)
@@ -20,7 +19,6 @@ end
 
 describe 'Lexer2' do
   include EgrammarLexer2Spec
-  include ParserRspecHelper
 
   {
     :LISTSTART => '[',
@@ -116,13 +114,8 @@ describe 'Lexer2' do
   end
 
   context 'when app_managment is (turned) on' do
-    before(:each) do
-      with_app_management(true)
-    end
-
-    after(:each) do
-      with_app_management(false)
-    end
+    before(:each) { Puppet[:app_management] = true }
+    after(:each) { Puppet[:app_management] = false }
 
     {
       "application"  => :APPLICATION,

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

@@ -1,18 +1,13 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
-require_relative './parser_rspec_helper'
+require_relative 'parser_rspec_helper'
 
 describe "egrammar parsing of 'application'" do
   include ParserRspecHelper
 
-  before(:each) do
-    with_app_management(true)
-  end
-
-  after(:each) do
-    with_app_management(false)
-  end
+  before(:each) { Puppet[:app_management] = true }
+  after(:each) { Puppet[:app_management] = false }
 
   it "an empty body" do
     expect(dump(parse("application foo { }"))).to eq("(application foo () ())")

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

@@ -168,6 +168,25 @@ describe "egrammar parsing basic expressions" do
       expect(parse("[]").current.body.length).to eq(2)
       expect(parse("[ ]").current.body.length).to eq(3)
     end
+
+    {
+      'keyword' => %w(type function),
+      'reserved word' => %w(application site produces consumes)
+    }.each_pair do |word_type, words|
+      words.each do |word|
+        it "allows the #{word_type} '#{word}' in a list" do
+          expect(dump(parse("$a = [#{word}]"))).to(eq("(= $a ([] '#{word}'))"))
+        end
+
+        it "allows the #{word_type} '#{word}' as a key in a hash" do
+          expect(dump(parse("$a = {#{word}=>'x'}"))).to(eq("(= $a ({} ('#{word}' 'x')))"))
+        end
+
+        it "allows the #{word_type} '#{word}' as a value in a hash" do
+          expect(dump(parse("$a = {'x'=>#{word}}"))).to(eq("(= $a ({} ('x' '#{word}')))"))
+        end
+      end
+    end
   end
 
   context "When parsing indexed access" do

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

@@ -1,20 +1,13 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
-
-# relative to this spec file (./) does not work as this file is loaded by rspec
-require File.join(File.dirname(__FILE__), '/parser_rspec_helper')
+require_relative 'parser_rspec_helper'
 
 describe "egrammar parsing of capability mappings" do
   include ParserRspecHelper
 
-  before(:each) do
-    with_app_management(true)
-  end
-
-  after(:each) do
-    with_app_management(false)
-  end
+  before(:each) { Puppet[:app_management] = true }
+  after(:each) { Puppet[:app_management] = false }
 
   context "when parsing 'produces'" do
     it "the ast contains produces and attributes" do

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

@@ -1,20 +1,13 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/pops'
-
-# relative to this spec file (./) does not work as this file is loaded by rspec
-require File.join(File.dirname(__FILE__), '/parser_rspec_helper')
+require_relative 'parser_rspec_helper'
 
 describe "egrammar parsing of site expression" do
   include ParserRspecHelper
 
-  before(:each) do
-    with_app_management(true)
-  end
-
-  after(:each) do
-    with_app_management(false)
-  end
+  before(:each) { Puppet[:app_management] = true }
+  after(:each) { Puppet[:app_management] = false }
 
   context "when parsing 'site'" do
     it "an empty body is allowed" do
@@ -35,4 +28,20 @@ describe "egrammar parsing of site expression" do
       expect(dump(parse(prog))).to eq(ast)
     end
   end
+
+  context 'When parsing collections containing application management specific keywords' do
+    %w(application site produces consumes).each do |keyword|
+      it "allows the keyword '#{keyword}' in a list" do
+        expect(dump(parse("$a = [#{keyword}]"))).to(eq("(= $a ([] '#{keyword}'))"))
+      end
+
+      it "allows the keyword '#{keyword}' as a key in a hash" do
+        expect(dump(parse("$a = {#{keyword}=>'x'}"))).to(eq("(= $a ({} ('#{keyword}' 'x')))"))
+      end
+
+      it "allows the keyword '#{keyword}' as a value in a hash" do
+        expect(dump(parse("$a = {'x'=>#{keyword}}"))).to(eq("(= $a ({} ('x' '#{keyword}')))"))
+      end
+    end
+  end
 end

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

@@ -5,10 +5,6 @@ require File.join(File.dirname(__FILE__), '/../factory_rspec_helper')
 module ParserRspecHelper
   include FactoryRspecHelper
 
-  def with_app_management(flag)
-    Puppet[:app_management] = flag
-  end
-
   def parse(code)
     parser = Puppet::Pops::Parser::Parser.new()
     parser.parse_string(code)

data/spec/unit/pops/types/enumeration_spec.rb

@@ -1,50 +1,51 @@
 require 'spec_helper'
 require 'puppet/pops'
 
+module Puppet::Pops::Types
 describe 'The enumeration support' do
   it 'produces an enumerator for Array' do
-  expect(Puppet::Pops::Types::Enumeration.enumerator([1,2,3]).respond_to?(:next)).to eql(true)
+  expect(Enumeration.enumerator([1,2,3]).respond_to?(:next)).to eql(true)
   end
 
   it 'produces an enumerator for Hash' do
-    expect(Puppet::Pops::Types::Enumeration.enumerator({:a=>1}).respond_to?(:next)).to eql(true)
+    expect(Enumeration.enumerator({:a=>1}).respond_to?(:next)).to eql(true)
   end
 
   it 'produces a char enumerator for String' do
-    enum = Puppet::Pops::Types::Enumeration.enumerator("abc")
+    enum = Enumeration.enumerator("abc")
     expect(enum.respond_to?(:next)).to eql(true)
     expect(enum.next).to eql('a')
   end
 
   it 'produces an enumerator for integer times' do
-    enum = Puppet::Pops::Types::Enumeration.enumerator(2)
+    enum = Enumeration.enumerator(2)
     expect(enum.next).to eql(0)
     expect(enum.next).to eql(1)
     expect{enum.next}.to raise_error(StopIteration)
   end
 
   it 'produces an enumerator for Integer range' do
-    range = Puppet::Pops::Types::TypeFactory.range(1,2)
-    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    range = TypeFactory.range(1,2)
+    enum = Enumeration.enumerator(range)
     expect(enum.next).to eql(1)
     expect(enum.next).to eql(2)
     expect{enum.next}.to raise_error(StopIteration)
   end
 
   it 'does not produce an enumerator for infinite Integer range' do
-    range = Puppet::Pops::Types::TypeFactory.range(1,:default)
-    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    range = TypeFactory.range(1,:default)
+    enum = Enumeration.enumerator(range)
     expect(enum).to be_nil
-    range = Puppet::Pops::Types::TypeFactory.range(:default,2)
-    enum = Puppet::Pops::Types::Enumeration.enumerator(range)
+    range = TypeFactory.range(:default,2)
+    enum = Enumeration.enumerator(range)
     expect(enum).to be_nil
   end
 
   [3.14, /.*/, true, false, nil, :something].each do |x|
     it "does not produce an enumerator for object of type #{x.class}" do
-      enum = Puppet::Pops::Types::Enumeration.enumerator(x)
+      enum = Enumeration.enumerator(x)
       expect(enum).to be_nil
     end
   end
-
+end
 end