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

data/spec/unit/parser/functions/file_spec.rb

@@ -13,10 +13,6 @@ describe "the 'file' function" do
   let :compiler do Puppet::Parser::Compiler.new(node) end
   let :scope    do Puppet::Parser::Scope.new(compiler) end
 
-  it "should exist" do
-    Puppet::Parser::Functions.function("file").should == "function_file"
-  end
-
   def with_file_content(content)
     path = tmpfile('file-function')
     file = File.new(path, 'w')
@@ -31,7 +27,17 @@ describe "the 'file' function" do
     end
   end
 
-  it "should return the first file if given two files" do
+  it "should read a file from a module path" do
+    with_file_content('file content') do |name|
+      mod = mock 'module'
+      mod.stubs(:file).with('myfile').returns(name)
+      compiler.environment.stubs(:module).with('mymod').returns(mod)
+
+      scope.function_file(['mymod/myfile']).should == 'file content'
+    end
+  end
+
+  it "should return the first file if given two files with absolute paths" do
     with_file_content('one') do |one|
       with_file_content('two') do |two|
         scope.function_file([one, two]).should == "one"
@@ -39,6 +45,43 @@ describe "the 'file' function" do
     end
   end
 
+  it "should return the first file if given two files with module paths" do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        mod = mock 'module'
+        compiler.environment.expects(:module).with('mymod').returns(mod)
+        mod.expects(:file).with('one').returns(one)
+        mod.stubs(:file).with('two').returns(two)
+
+        scope.function_file(['mymod/one','mymod/two']).should == 'one'
+      end
+    end
+  end
+
+  it "should return the first file if given two files with mixed paths, absolute first" do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        mod = mock 'module'
+        compiler.environment.stubs(:module).with('mymod').returns(mod)
+        mod.stubs(:file).with('two').returns(two)
+
+        scope.function_file([one,'mymod/two']).should == 'one'
+      end
+    end
+  end
+
+  it "should return the first file if given two files with mixed paths, module first" do
+    with_file_content('one') do |one|
+      with_file_content('two') do |two|
+        mod = mock 'module'
+        compiler.environment.expects(:module).with('mymod').returns(mod)
+        mod.stubs(:file).with('two').returns(two)
+
+        scope.function_file(['mymod/two',one]).should == 'two'
+      end
+    end
+  end
+
   it "should not fail when some files are absent" do
     expect {
       with_file_content('one') do |one|

data/spec/unit/parser/functions/include_spec.rb

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'unit/parser/functions/shared'
 
 describe "the 'include' function" do
   before :all do
@@ -46,6 +47,19 @@ describe "the 'include' function" do
 
   it "should raise if the class is not found" do
     @scope.stubs(:source).returns(true)
-    expect { @scope.function_include(["nosuchclass"]) }.to raise_error Puppet::Error
+    expect { @scope.function_include(["nosuchclass"]) }.to raise_error(Puppet::Error)
+  end
+
+  describe "When the future parser is in use" do
+    require 'puppet/pops'
+    require 'puppet_spec/compiler'
+    include PuppetSpec::Compiler
+
+    before(:each) do
+      Puppet[:parser] = 'future'
+    end
+
+    it_should_behave_like 'all functions transforming relative to absolute names', :function_include
+    it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :include
   end
 end

data/spec/unit/parser/functions/realize_spec.rb

@@ -1,53 +1,61 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
+require 'matchers/resource'
+require 'puppet_spec/compiler'
 
 describe "the realize function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
+  include Matchers::Resource
+  include PuppetSpec::Compiler
 
-  before :each do
-    @collector = stub_everything 'collector'
-    node      = Puppet::Node.new('localhost')
-    @compiler = Puppet::Parser::Compiler.new(node)
-    @scope    = Puppet::Parser::Scope.new(@compiler)
-    @compiler.stubs(:add_collection).with(@collector)
-  end
+  it "realizes a single, referenced resource" do
+    catalog = compile_to_catalog(<<-EOM)
+      @notify { testing: }
+      realize(Notify[testing])
+    EOM
 
-  it "should exist" do
-    Puppet::Parser::Functions.function("realize").should == "function_realize"
+    expect(catalog).to have_resource("Notify[testing]")
   end
 
-  it "should create a Collector when called" do
-
-    Puppet::Parser::Collector.expects(:new).returns(@collector)
+  it "realizes multiple resources" do
+    catalog = compile_to_catalog(<<-EOM)
+      @notify { testing: }
+      @notify { other: }
+      realize(Notify[testing], Notify[other])
+    EOM
 
-    @scope.function_realize(["test"])
+    expect(catalog).to have_resource("Notify[testing]")
+    expect(catalog).to have_resource("Notify[other]")
   end
 
-  it "should assign the passed-in resources to the collector" do
-    Puppet::Parser::Collector.stubs(:new).returns(@collector)
+  it "realizes resources provided in arrays" do
+    catalog = compile_to_catalog(<<-EOM)
+      @notify { testing: }
+      @notify { other: }
+      realize([Notify[testing], [Notify[other]]])
+    EOM
 
-    @collector.expects(:resources=).with(["test"])
-
-    @scope.function_realize(["test"])
+    expect(catalog).to have_resource("Notify[testing]")
+    expect(catalog).to have_resource("Notify[other]")
   end
 
-  it "should flatten the resources assigned to the collector" do
-    Puppet::Parser::Collector.stubs(:new).returns(@collector)
-
-    @collector.expects(:resources=).with(["test"])
-
-    @scope.function_realize([["test"]])
+  it "fails when the resource does not exist" do
+    expect do
+      compile_to_catalog(<<-EOM)
+        realize(Notify[missing])
+      EOM
+    end.to raise_error(Puppet::Error, /Failed to realize/)
   end
 
-  it "should let the compiler know this collector" do
-    Puppet::Parser::Collector.stubs(:new).returns(@collector)
-    @collector.stubs(:resources=).with(["test"])
-
-    @compiler.expects(:add_collection).with(@collector)
-
-    @scope.function_realize(["test"])
+  it "fails when no parameters given" do
+    expect do
+      compile_to_catalog(<<-EOM)
+        realize()
+      EOM
+    end.to raise_error(Puppet::Error, /Wrong number of arguments/)
   end
 
+  it "silently does nothing when an empty array of resources is given" do
+    compile_to_catalog(<<-EOM)
+      realize([])
+    EOM
+  end
 end

data/spec/unit/parser/functions/require_spec.rb

@@ -1,5 +1,6 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
+require 'unit/parser/functions/shared'
 
 describe "the require function" do
   before :all do
@@ -26,13 +27,13 @@ describe "the require function" do
   end
 
   it "should delegate to the 'include' puppet function" do
-    @scope.expects(:function_include).with(["myclass"])
+    @scope.compiler.expects(:evaluate_classes).with(["myclass"], @scope, false)
 
     @scope.function_require(["myclass"])
   end
 
-  it "should set the 'require' prarameter on the resource to a resource reference" do
-    @scope.stubs(:function_include)
+  it "should set the 'require' parameter on the resource to a resource reference" do
+    @scope.compiler.stubs(:evaluate_classes)
     @scope.function_require(["myclass"])
 
     @resource["require"].should be_instance_of(Array)
@@ -40,7 +41,7 @@ describe "the require function" do
   end
 
   it "should lookup the absolute class path" do
-    @scope.stubs(:function_include)
+    @scope.compiler.stubs(:evaluate_classes)
 
     @scope.expects(:find_hostclass).with("myclass").returns(@klass)
     @klass.expects(:name).returns("myclass")
@@ -49,7 +50,7 @@ describe "the require function" do
   end
 
   it "should append the required class to the require parameter" do
-    @scope.stubs(:function_include)
+    @scope.compiler.stubs(:evaluate_classes)
 
     one = Puppet::Resource.new(:file, "/one")
     @resource[:require] = one
@@ -58,4 +59,17 @@ describe "the require function" do
     @resource[:require].should be_include(one)
     @resource[:require].detect { |r| r.to_s == "Class[Myclass]" }.should be_instance_of(Puppet::Resource)
   end
+
+  describe "When the future parser is in use" do
+    require 'puppet/pops'
+    require 'puppet_spec/compiler'
+    include PuppetSpec::Compiler
+
+    before(:each) do
+      Puppet[:parser] = 'future'
+    end
+
+    it_should_behave_like 'all functions transforming relative to absolute names', :function_require
+    it_should_behave_like 'an inclusion function, regardless of the type of class reference,', :require
+  end
 end

data/spec/unit/parser/functions/search_spec.rb

@@ -20,4 +20,9 @@ describe "the 'search' function" do
     scope.expects(:add_namespace).with("who")
     scope.function_search(["where", "what", "who"])
   end
+
+  it "is deprecated" do
+    Puppet.expects(:deprecation_warning).with("The 'search' function is deprecated. See http://links.puppetlabs.com/search-function-deprecation")
+    scope.function_search(['wat'])
+  end
 end

data/spec/unit/parser/functions/shared.rb

@@ -0,0 +1,82 @@
+shared_examples_for 'all functions transforming relative to absolute names' do |func_method|
+
+  it 'transforms relative names to absolute' do
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
+    @scope.send(func_method, ["myclass"])
+  end
+
+  it 'accepts a Class[name] type' do
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
+    @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.host_class('myclass')])
+  end
+
+  it 'accepts a Resource[class, name] type' do
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
+    @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('class', 'myclass')])
+  end
+
+  it 'raises and error for unspecific Class' do
+    expect {
+      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.host_class()])
+    }.to raise_error(ArgumentError, /Cannot use an unspecific Class\[\] Type/)
+  end
+
+  it 'raises and error for Resource that is not of class type' do
+    expect {
+      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('file')])
+    }.to raise_error(ArgumentError, /Cannot use a Resource\[file\] where a Resource\['class', name\] is expected/)
+  end
+
+  it 'raises and error for Resource that is unspecific' do
+    expect {
+      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource()])
+    }.to raise_error(ArgumentError, /Cannot use an unspecific Resource\[\] where a Resource\['class', name\] is expected/)
+  end
+
+  it 'raises and error for Resource[class] that is unspecific' do
+    expect {
+      @scope.send(func_method, [Puppet::Pops::Types::TypeFactory.resource('class')])
+    }.to raise_error(ArgumentError, /Cannot use an unspecific Resource\['class'\] where a Resource\['class', name\] is expected/)
+  end
+
+end
+
+shared_examples_for 'an inclusion function, regardless of the type of class reference,' do |function|
+
+    it "and #{function} a class absolutely, even when a relative namespaced class of the same name is present" do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        class foo {
+          class bar { }
+          #{function} bar
+        }
+        class bar { }
+        include foo
+      MANIFEST
+      expect(catalog.classes).to include('foo','bar')
+    end
+
+    it "and #{function} a class absolutely by Class['type'] reference" do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        class foo {
+          class bar { }
+          #{function} Class['bar'] 
+        }
+        class bar { }
+        include foo
+      MANIFEST
+      expect(catalog.classes).to include('foo','bar')
+    end
+
+    it "and #{function} a class absolutely by Resource['type','title'] reference" do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        class foo {
+          class bar { }
+          #{function} Resource['class','bar'] 
+        }
+        class bar { }
+        include foo
+      MANIFEST
+      expect(catalog.classes).to include('foo','bar')
+    end
+
+end

data/spec/unit/parser/functions_spec.rb

@@ -38,7 +38,7 @@ describe Puppet::Parser::Functions do
 
     it "instruments the function to profile the execution" do
       messages = []
-      Puppet::Util::Profiler.current = Puppet::Util::Profiler::WallClock.new(proc { |msg| messages << msg }, "id")
+      Puppet::Util::Profiler.add_profiler(Puppet::Util::Profiler::WallClock.new(proc { |msg| messages << msg }, "id"))
 
       Puppet::Parser::Functions.newfunction("name", :type => :rvalue) { |args| }
       callable_functions_from(function_module).function_name([])

data/spec/unit/parser/lexer_spec.rb

@@ -279,7 +279,8 @@ describe Puppet::Parser::Lexer::TOKENS[:NAME] do
 
   it "should return itself and the value if the matched term is not a keyword" do
     Puppet::Parser::Lexer::KEYWORDS.expects(:lookup).returns(nil)
-    @token.convert(stub("lexer"), "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
+    lexer = stub("lexer")
+    @token.convert(lexer, "myval").should == [Puppet::Parser::Lexer::TOKENS[:NAME], "myval"]
   end
 
   it "should return the keyword token and the value if the matched term is a keyword" do
@@ -845,6 +846,14 @@ describe "Puppet::Parser::Lexer in the old tests" do
   end
 end
 
+describe 'Puppet::Parser::Lexer handles reserved words' do
+    ['function', 'private', 'attr', 'type'].each do |reserved_bare_word|
+      it "by delivering '#{reserved_bare_word}' as a bare word" do
+        expect(tokens_scanned_from(reserved_bare_word)).to eq([[:NAME, {:value=>reserved_bare_word, :line => 1}]])
+      end
+    end
+end
+
 describe "Puppet::Parser::Lexer in the old tests when lexing example files" do
   my_fixtures('*.pp') do |file|
     it "should correctly lex #{file}" do

data/spec/unit/parser/type_loader_spec.rb

@@ -3,7 +3,6 @@ require 'spec_helper'
 
 require 'puppet/parser/type_loader'
 require 'puppet/parser/parser_factory'
-require 'puppet/parser/e_parser_adapter'
 require 'puppet_spec/modules'
 require 'puppet_spec/files'
 

data/spec/unit/pops/benchmark_spec.rb

@@ -118,7 +118,7 @@ $a = "interpolate ${foo} and stuff"
   end
 
   context "Measure Evaluator" do
-    let(:parser) { Puppet::Pops::Parser::EvaluatingParser::Transitional.new }
+    let(:parser) { Puppet::Pops::Parser::EvaluatingParser.new }
     let(:node) { 'node.example.com' }
     let(:scope) { s = create_test_scope_for_node(node); s }
     it "evaluator", :profile => true do

data/spec/unit/pops/binder/bindings_composer_spec.rb

@@ -34,31 +34,33 @@ describe 'BinderComposer' do
     it 'should load everything without errors' do
       Puppet.settings[:confdir] = config_directory
       Puppet.settings[:libdir] = File.join(config_directory, 'lib')
-      Puppet.settings[:modulepath] = File.join(config_directory, 'modules')
-      # this ensure the binder is active at the right time
-      # (issues with getting a /dev/null path for "confdir" / "libdir")
-      raise "Binder not active" unless scope.compiler.is_binder_active?
 
-      diagnostics = diag
-      composer = Puppet::Pops::Binder::BindingsComposer.new()
-      the_scope = scope
-      the_scope['fqdn'] = 'localhost'
-      the_scope['environment'] = 'production'
-      layered_bindings = composer.compose(scope)
-      # puts Puppet::Pops::Binder::BindingsModelDumper.new().dump(layered_bindings)
-      binder = Puppet::Pops::Binder::Binder.new(layered_bindings)
-      injector = Puppet::Pops::Binder::Injector.new(binder)
-      expect(injector.lookup(scope, 'awesome_x')).to be == 'golden'
-      expect(injector.lookup(scope, 'good_x')).to be == 'golden'
-      expect(injector.lookup(scope, 'rotten_x')).to be == nil
-      expect(injector.lookup(scope, 'the_meaning_of_life')).to be == 42
-      expect(injector.lookup(scope, 'has_funny_hat')).to be == 'the pope'
-      expect(injector.lookup(scope, 'all your base')).to be == 'are belong to us'
-      expect(injector.lookup(scope, 'env_meaning_of_life')).to be == 'production thinks it is 42'
-      expect(injector.lookup(scope, '::quick::brown::fox')).to be == 'echo: quick brown fox'
+      Puppet.override(:environments => Puppet::Environments::Static.new(Puppet::Node::Environment.create(:production, [File.join(config_directory, 'modules')]))) do
+        # this ensure the binder is active at the right time
+        # (issues with getting a /dev/null path for "confdir" / "libdir")
+        raise "Binder not active" unless scope.compiler.is_binder_active?
+
+        diagnostics = diag
+        composer = Puppet::Pops::Binder::BindingsComposer.new()
+        the_scope = scope
+        the_scope['fqdn'] = 'localhost'
+        the_scope['environment'] = 'production'
+        layered_bindings = composer.compose(scope)
+        # puts Puppet::Pops::Binder::BindingsModelDumper.new().dump(layered_bindings)
+        binder = Puppet::Pops::Binder::Binder.new(layered_bindings)
+        injector = Puppet::Pops::Binder::Injector.new(binder)
+        expect(injector.lookup(scope, 'awesome_x')).to be == 'golden'
+        expect(injector.lookup(scope, 'good_x')).to be == 'golden'
+        expect(injector.lookup(scope, 'rotten_x')).to be == nil
+        expect(injector.lookup(scope, 'the_meaning_of_life')).to be == 42
+        expect(injector.lookup(scope, 'has_funny_hat')).to be == 'the pope'
+        expect(injector.lookup(scope, 'all your base')).to be == 'are belong to us'
+        expect(injector.lookup(scope, 'env_meaning_of_life')).to be == 'production thinks it is 42'
+        expect(injector.lookup(scope, '::quick::brown::fox')).to be == 'echo: quick brown fox'
+      end
     end
   end
 
   # TODO: test error conditions (see BinderConfigChecker for what to test)
 
-end
+end