puppet 3.6.2-x86-mingw32 → 3.7.0-x86-mingw32

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

@@ -63,8 +63,8 @@ describe 'Puppet::Pops::Evaluator::EvaluatorImpl' do
         evaluate(literal('x').not()).should == false
       end
 
-      it "''             == false" do
-        evaluate(literal('').not()).should == true
+      it "''             == true" do
+        evaluate(literal('').not()).should == false
       end
 
       it ":undef         == false" do

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

@@ -49,111 +49,6 @@ describe 'Puppet::Pops::Impl::EvaluatorImpl' do
         expect { evaluate_l(block(var('a').set(10), var('a').set(20))) }.to raise_error(/Cannot reassign variable a/)
       end
 
-      context "-= operations" do
-        # Also see collections_ops_spec.rb where delete via - is fully tested, here only the
-        # the -= operation itself is tested (there are many combinations)
-        #
-        it 'deleting from non existing value produces :undef, nil -= ?' do
-          top_scope_block = var('b').set([1,2,3])
-          local_scope_block = block(var('a').minus_set([4]), fqn('a').var)
-          evaluate_l(top_scope_block, local_scope_block).should == :undef
-        end
-
-        it 'deletes from a list' do
-          top_scope_block = var('a').set([1,2,3])
-          local_scope_block = block(var('a').minus_set([2]), fqn('a').var())
-          evaluate_l(top_scope_block, local_scope_block).should == [1,3]
-        end
-
-        it 'deletes from a hash' do
-          top_scope_block = var('a').set({'a'=>1,'b'=>2,'c'=>3})
-          local_scope_block = block(var('a').minus_set('b'), fqn('a').var())
-          evaluate_l(top_scope_block, local_scope_block).should == {'a'=>1,'c'=>3}
-        end
-      end
-
-      context "+= operations" do
-        # Also see collections_ops_spec.rb where concatenation via + is fully tested
-        it "appending to non existing value, nil += []" do
-          top_scope_block = var('b').set([1,2,3])
-          local_scope_block = var('a').plus_set([4])
-          evaluate_l(top_scope_block, local_scope_block).should == [4]
-        end
-
-        context "appending to list" do
-          it "from list, [] += []" do
-            top_scope_block = var('a').set([1,2,3])
-            local_scope_block = block(var('a').plus_set([4]), fqn('a').var())
-            evaluate_l(top_scope_block, local_scope_block).should == [1,2,3,4]
-          end
-
-          it "from hash, [] += {a=>b}" do
-            top_scope_block = var('a').set([1,2,3])
-            local_scope_block = block(var('a').plus_set({'a' => 1, 'b'=>2}), fqn('a').var())
-            evaluate_l(top_scope_block, local_scope_block).should satisfy {|result|
-              # hash in 1.8.7 is not insertion order preserving, hence this hoop
-             result == [1,2,3,['a',1],['b',2]] || result == [1,2,3,['b',2],['a',1]]
-            }
-          end
-
-          it "from single value, [] += x" do
-            top_scope_block = var('a').set([1,2,3])
-            local_scope_block = block(var('a').plus_set(4), fqn('a').var())
-            evaluate_l(top_scope_block, local_scope_block).should == [1,2,3,4]
-          end
-
-          it "from embedded list, [] += [[x]]" do
-            top_scope_block = var('a').set([1,2,3])
-            local_scope_block = block(var('a').plus_set([[4,5]]), fqn('a').var())
-            evaluate_l(top_scope_block, local_scope_block).should == [1,2,3,[4,5]]
-          end
-        end
-
-        context "appending to hash" do
-          it "from hash, {a=>b} += {x=>y}" do
-            top_scope_block = var('a').set({'a' => 1, 'b' => 2})
-            local_scope_block = block(var('a').plus_set({'c' => 3}), fqn('a').var())
-            evaluate_l(top_scope_block, local_scope_block) do |scope|
-              # Assert no change to top scope hash
-              scope['a'].should == {'a' =>1, 'b'=> 2}
-            end.should == {'a' => 1, 'b' => 2, 'c' => 3}
-          end
-
-          it "from list, {a=>b} += ['x', y]" do
-            top_scope_block = var('a').set({'a' => 1, 'b' => 2})
-            local_scope_block = block(var('a').plus_set(['c', 3]), fqn('a').var())
-            evaluate_l(top_scope_block, local_scope_block) do |scope|
-              # Assert no change to top scope hash
-              scope['a'].should == {'a' =>1, 'b'=> 2}
-            end.should == {'a' => 1, 'b' => 2, 'c' => 3}
-          end
-
-          it "with overwrite from hash, {a=>b} += {a=>c}" do
-            top_scope_block = var('a').set({'a' => 1, 'b' => 2})
-            local_scope_block = block(var('a').plus_set({'b' => 4, 'c' => 3}),fqn('a').var())
-            evaluate_l(top_scope_block, local_scope_block) do |scope|
-              # Assert no change to top scope hash
-              scope['a'].should == {'a' =>1, 'b'=> 2}
-            end.should == {'a' => 1, 'b' => 4, 'c' => 3}
-          end
-
-          it "with overwrite from list, {a=>b} += ['a', c]" do
-            top_scope_block = var('a').set({'a' => 1, 'b' => 2})
-            local_scope_block = block(var('a').plus_set(['b', 4, 'c', 3]), fqn('a').var())
-            evaluate_l(top_scope_block, local_scope_block) do |scope|
-              # Assert no change to topscope hash
-              scope['a'].should == {'a' =>1, 'b'=> 2}
-            end.should == {'a' => 1, 'b' => 4, 'c' => 3}
-          end
-
-          it "from odd length array - error" do
-            top_scope_block = var('a').set({'a' => 1, 'b' => 2})
-            local_scope_block = var('a').plus_set(['b', 4, 'c'])
-            expect { evaluate_l(top_scope_block, local_scope_block) }.to raise_error(/Append assignment \+= failed with error: odd number of arguments for Hash/)
-          end
-        end
-      end
-
       context "access to numeric variables" do
         it "without a match" do
           evaluate_l(block(literal(2) + literal(2),

data/spec/unit/pops/issues_spec.rb

@@ -23,4 +23,174 @@ describe "Puppet::Pops::Issues" do
     x = Puppet::Pops::Issues::NOT_TOP_LEVEL
     x.format().should == "Classes, definitions, and nodes may only appear at toplevel or inside other classes"
   end
+
+end
+
+describe "Puppet::Pops::IssueReporter" do
+
+  let(:acceptor) { Puppet::Pops::Validation::Acceptor.new }
+
+  def fake_positioned(number)
+    stub("positioned_#{number}", :line => number, :pos => number)
+  end
+
+  def diagnostic(severity,  number)
+    Puppet::Pops::Validation::Diagnostic.new(
+      severity,
+      Puppet::Pops::Issues::Issue.new(number) { "#{severity}#{number}" },
+      "#{severity}file",
+      fake_positioned(number))
+  end
+
+  def warning(number)
+    diagnostic(:warning, number)
+  end
+
+  def deprecation(number)
+    diagnostic(:deprecation, number)
+  end
+
+  def error(number)
+    diagnostic(:error, number)
+  end
+
+  context "given warnings" do
+
+    before(:each) do
+      acceptor.accept( warning(1) )
+      acceptor.accept( deprecation(1) )
+    end
+
+    it "emits warnings if told to emit them" do
+      Puppet.expects(:warning).twice.with(regexp_matches(/warning1|deprecation1/))
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
+    end
+
+    it "does not emit warnings if not told to emit them" do
+      Puppet.expects(:warning).never
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, {})
+    end
+
+    it "emits no warnings if :max_warnings is 0" do
+      acceptor.accept( warning(2) )
+      Puppet[:max_warnings] = 0
+      Puppet.expects(:warning).once.with(regexp_matches(/deprecation1/))
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
+    end
+
+    it "emits no more than 1 warning if :max_warnings is 1" do
+      acceptor.accept( warning(2) )
+      acceptor.accept( warning(3) )
+      Puppet[:max_warnings] = 1
+      Puppet.expects(:warning).twice.with(regexp_matches(/warning1|deprecation1/))
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
+    end
+
+    it "does not emit more deprecations warnings than the max deprecation warnings" do
+      acceptor.accept( deprecation(2) )
+      Puppet[:max_deprecations] = 0
+      Puppet.expects(:warning).once.with(regexp_matches(/warning1/))
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
+    end
+
+    it "does not emit deprecation warnings, but does emit regular warnings if disable_warnings includes deprecations" do
+      Puppet[:disable_warnings] = 'deprecations'
+      Puppet.expects(:warning).once.with(regexp_matches(/warning1/))
+      Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
+    end
+  end
+
+  context "given errors" do
+    it "logs nothing, but raises the given :message if :emit_errors is repressing error logging" do
+      acceptor.accept( error(1) )
+      Puppet.expects(:err).never
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_errors => false, :message => 'special'})
+      end.to raise_error(Puppet::ParseError, 'special')
+    end
+
+    it "prefixes :message if a single error is raised" do
+      acceptor.accept( error(1) )
+      Puppet.expects(:err).never
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
+      end.to raise_error(Puppet::ParseError, /special error1/)
+    end
+
+    it "logs nothing and raises immediately if there is only one error" do
+      acceptor.accept( error(1) )
+      Puppet.expects(:err).never
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
+      end.to raise_error(Puppet::ParseError, /error1/)
+    end
+
+    it "logs nothing and raises immediately if there are multiple errors but max_errors is 0" do
+      acceptor.accept( error(1) )
+      acceptor.accept( error(2) )
+      Puppet[:max_errors] = 0
+      Puppet.expects(:err).never
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
+      end.to raise_error(Puppet::ParseError, /error1/)
+    end
+
+    it "logs the :message if there is more than one allowed error" do
+      acceptor.accept( error(1) )
+      acceptor.accept( error(2) )
+      Puppet.expects(:err).times(3).with(regexp_matches(/error1|error2|special/))
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :message => 'special'})
+      end.to raise_error(Puppet::ParseError, /Giving up/)
+    end
+
+    it "emits accumulated errors before raising a 'giving up' message if there are more errors than allowed" do
+      acceptor.accept( error(1) )
+      acceptor.accept( error(2) )
+      acceptor.accept( error(3) )
+      Puppet[:max_errors] = 2
+      Puppet.expects(:err).times(2).with(regexp_matches(/error1|error2/))
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
+      end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
+    end
+
+    it "emits accumulated errors before raising a 'giving up' message if there are multiple errors but fewer than limits" do
+      acceptor.accept( error(1) )
+      acceptor.accept( error(2) )
+      acceptor.accept( error(3) )
+      Puppet[:max_errors] = 4
+      Puppet.expects(:err).times(3).with(regexp_matches(/error[123]/))
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
+      end.to raise_error(Puppet::ParseError, /3 errors.*Giving up/)
+    end
+
+    it "emits errors regardless of disable_warnings setting" do
+      acceptor.accept( error(1) )
+      acceptor.accept( error(2) )
+      Puppet[:disable_warnings] = 'deprecations'
+      Puppet.expects(:err).times(2).with(regexp_matches(/error1|error2/))
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { })
+      end.to raise_error(Puppet::ParseError, /Giving up/)
+    end
+  end
+
+  context "given both" do
+
+    it "logs warnings and errors" do
+      acceptor.accept( warning(1) )
+      acceptor.accept( error(1) )
+      acceptor.accept( error(2) )
+      acceptor.accept( error(3) )
+      acceptor.accept( deprecation(1) )
+      Puppet[:max_errors] = 2
+      Puppet.expects(:warning).twice.with(regexp_matches(/warning1|deprecation1/))
+      Puppet.expects(:err).times(2).with(regexp_matches(/error[123]/))
+      expect do
+        Puppet::Pops::IssueReporter.assert_and_report(acceptor, { :emit_warnings => true })
+      end.to raise_error(Puppet::ParseError, /3 errors.*2 warnings.*Giving up/)
+    end
+  end
 end

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

@@ -36,6 +36,23 @@ describe 'dependency loader' do
       expect(function.class.name).to eq('testmodule::foo')
       expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
     end
+
+    it 'can load something in a qualified name space more than once' do
+      module_dir = dir_containing('testmodule', {
+      'lib' => { 'puppet' => { 'functions' => { 'testmodule' => {
+        'foo.rb' => 'Puppet::Functions.create_function("testmodule::foo") { def foo; end; }'
+      }}}}})
+      module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
+      dep_loader = Puppet::Pops::Loader::DependencyLoader.new(static_loader, 'test-dep', [module_loader])
+
+      function = dep_loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+      expect(function.class.name).to eq('testmodule::foo')
+      expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
+
+      function = dep_loader.load_typed(typed_name(:function, 'testmodule::foo')).value
+      expect(function.class.name).to eq('testmodule::foo')
+      expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
+    end
   end
 
   def typed_name(type, name)

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

@@ -5,7 +5,6 @@ require 'puppet/loaders'
 
 describe 'loader paths' do
   include PuppetSpec::Files
-  before(:each) { Puppet[:biff] = true }
 
   let(:static_loader) { Puppet::Pops::Loader::StaticLoader.new() }
   let(:unused_loaders) { nil }
@@ -17,17 +16,13 @@ describe 'loader paths' do
         'lib' => {
           'puppet' => {
             'functions' => {},
-            'parser' => {
-              'functions' => {},
-            }
           }}})
       module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, unused_loaders, 'testmodule', module_dir, 'test1')
 
       effective_paths = Puppet::Pops::Loader::LoaderPaths.relative_paths_for_type(:function, module_loader)
 
       expect(effective_paths.collect(&:generic_path)).to eq([
-        File.join(module_dir, 'lib', 'puppet', 'functions'), # 4x functions
-        File.join(module_dir, 'lib', 'puppet','parser', 'functions') # 3x functions
+        File.join(module_dir, 'lib', 'puppet', 'functions')
       ])
     end
 
@@ -39,8 +34,6 @@ describe 'loader paths' do
 
       expect(effective_paths.size).to be_eql(1)
       expect(effective_paths[0].generic_path).to be_eql(File.join(module_dir, 'lib', 'puppet', 'functions'))
-      expect(module_loader.path_index.size).to be_eql(1)
-      expect(module_loader.path_index.include?(File.join(module_dir, 'lib', 'puppet', 'functions', 'foo.rb'))).to be(true)
     end
 
     it 'all function smart-paths produces entries if they exist' do
@@ -48,19 +41,15 @@ describe 'loader paths' do
         'lib' => {
           'puppet' => {
             'functions' => {'foo4x.rb' => 'ignored in this test'},
-            'parser' => {
-              'functions' => {'foo3x.rb' => 'ignored in this test'},
-            }
           }}})
       module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, unused_loaders, 'testmodule', module_dir, 'test1')
 
       effective_paths = module_loader.smart_paths.effective_paths(:function)
 
-      expect(effective_paths.size).to eq(2)
-      expect(module_loader.path_index.size).to eq(2)
+      expect(effective_paths.size).to eq(1)
+      expect(module_loader.path_index.size).to eq(1)
       path_index = module_loader.path_index
-      expect(path_index.include?(File.join(module_dir, 'lib', 'puppet', 'functions', 'foo4x.rb'))).to eq(true)
-      expect(path_index.include?(File.join(module_dir, 'lib', 'puppet', 'parser', 'functions', 'foo3x.rb'))).to eq(true)
+      expect(path_index).to include(File.join(module_dir, 'lib', 'puppet', 'functions', 'foo4x.rb'))
     end
   end
 end

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

@@ -4,6 +4,25 @@ require 'puppet_spec/files'
 require 'puppet/pops'
 require 'puppet/loaders'
 
+describe 'loader helper classes' do
+  it 'NamedEntry holds values and is frozen' do
+    ne = Puppet::Pops::Loader::Loader::NamedEntry.new('name', 'value', 'origin')
+    expect(ne.frozen?).to be_true
+    expect(ne.typed_name).to eql('name')
+    expect(ne.origin).to eq('origin')
+    expect(ne.value).to eq('value')
+  end
+
+  it 'TypedName holds values and is frozen' do
+    tn = Puppet::Pops::Loader::Loader::TypedName.new(:function, '::foo::bar')
+    expect(tn.frozen?).to be_true
+    expect(tn.type).to eq(:function)
+    expect(tn.name_parts).to eq(['foo', 'bar'])
+    expect(tn.name).to eq('foo::bar')
+    expect(tn.qualified).to be_true
+  end
+end
+
 describe 'loaders' do
   include PuppetSpec::Files
 
@@ -29,17 +48,6 @@ describe 'loaders' do
     expect(loaders.private_environment_loader().to_s).to eql("(DependencyLoader 'environment' [])")
   end
 
-  it 'can load 3x system functions' do
-    Puppet[:biff] = true
-    loaders = Puppet::Pops::Loaders.new(empty_test_env)
-    puppet_loader = loaders.puppet_system_loader()
-
-    function = puppet_loader.load_typed(typed_name(:function, 'sprintf')).value
-
-    expect(function.class.name).to eq('sprintf')
-    expect(function).to be_a(Puppet::Functions::Function)
-  end
-
   it 'can load a function using a qualified or unqualified name from a module with metadata' do
     loaders = Puppet::Pops::Loaders.new(environment_for(module_with_metadata))
     modulea_loader = loaders.public_loader_for_module('modulea')
@@ -91,6 +99,18 @@ describe 'loaders' do
     expect(function.call({})).to eql("usee::callee() was told 'passed value' + I am user::caller()")
   end
 
+  it 'can load a function more than once from modules' do
+    env = environment_for(dependent_modules_with_metadata)
+    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()")
+
+    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
+
   def environment_for(*module_paths)
     Puppet::Node::Environment.create(:'*test*', module_paths, '')
   end

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

@@ -84,35 +84,6 @@ describe 'FileBased module loader' do
     expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
   end
 
-  context 'when delegating 3x to 4x' do
-    before(:each) { Puppet[:biff] = true }
-
-    it 'can load a 3x function API ruby function in global name space' do
-      module_dir = dir_containing('testmodule', {
-        'lib' => {
-          'puppet' => {
-            'parser' => {
-              'functions' => {
-                'foo3x.rb' => <<-CODE
-                  Puppet::Parser::Functions::newfunction(
-                    :foo3x, :type => :rvalue,
-                    :arity => 1
-                  ) do |args|
-                    args[0]
-                  end
-                CODE
-              }
-              }
-            }
-        }})
-
-     module_loader = Puppet::Pops::Loader::ModuleLoaders::FileBased.new(static_loader, loaders, 'testmodule', module_dir, 'test1')
-     function = module_loader.load_typed(typed_name(:function, 'foo3x')).value
-     expect(function.class.name).to eq('foo3x')
-     expect(function.is_a?(Puppet::Functions::Function)).to eq(true)
-    end
-  end
-
   def typed_name(type, name)
     Puppet::Pops::Loader::Loader::TypedName.new(type, name)
   end