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

data/spec/unit/functions/match_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+require 'puppet/pops'
+require 'puppet/loaders'
+
+describe 'the match function' do
+
+  before(:all) do
+    loaders = Puppet::Pops::Loaders.new(Puppet::Node::Environment.create(:testing, []))
+    Puppet.push_context({:loaders => loaders}, "test-examples")
+  end
+
+  after(:all) do
+    Puppet::Pops::Loaders.clear
+    Puppet::pop_context()
+  end
+
+  let(:func) do
+    Puppet.lookup(:loaders).puppet_system_loader.load(:function, 'match')
+  end
+
+  let(:type_parser) { Puppet::Pops::Types::TypeParser.new }
+
+
+  it 'matches string and regular expression without captures' do
+    expect(func.call({}, 'abc123', /[a-z]+[1-9]+/)).to eql(['abc123'])
+  end
+
+  it 'matches string and regular expression with captures' do
+    expect(func.call({}, 'abc123', /([a-z]+)([1-9]+)/)).to eql(['abc123', 'abc', '123'])
+  end
+
+  it 'produces nil if match is not found' do
+    expect(func.call({}, 'abc123', /([x]+)([6]+)/)).to be_nil
+  end
+
+  [ 'Pattern[/([a-z]+)([1-9]+)/]',       # regexp
+    'Pattern["([a-z]+)([1-9]+)"]',       # string
+    'Regexp[/([a-z]+)([1-9]+)/]',        # regexp type
+    'Pattern[/x9/, /([a-z]+)([1-9]+)/]', # regexp, first found matches
+  ].each do |pattern|
+    it "matches string and type #{pattern} with captures" do
+      expect(func.call({}, 'abc123', type(pattern))).to eql(['abc123', 'abc', '123'])
+    end
+  end
+
+  it 'matches an array of strings and yields a map of the result' do
+    expect(func.call({}, ['abc123', '2a', 'xyz2'], /([a-z]+)[1-9]+/)).to eql([['abc123', 'abc'], nil, ['xyz2', 'xyz']])
+  end
+
+  it 'raises error if Regexp type without regexp is used' do
+    expect{func.call({}, 'abc123', type('Regexp'))}.to raise_error(ArgumentError, /Given Regexp Type has no regular expression/)
+  end
+
+  def type(s)
+    Puppet::Pops::Types::TypeParser.new.parse(s) 
+  end
+end

data/spec/unit/{parser/methods → functions}/reduce_spec.rb

@@ -1,9 +1,12 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
+require 'matchers/resource'
+require 'shared_behaviours/iterative_functions'
 
 describe 'the reduce method' do
   include PuppetSpec::Compiler
+  include Matchers::Resource
 
   before :all do
     # enable switching back 
@@ -32,7 +35,17 @@ describe 'the reduce method' do
         file { "/file_$b": ensure => present }
       MANIFEST
 
-      catalog.resource(:file, "/file_6")['ensure'].should == 'present'
+      expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
+    end
+
+    it 'reduce on an array with captures rest in lambda' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1,2,3]
+        $b = $a.reduce |*$mx| { $mx[0] + $mx[1] }
+        file { "/file_$b": ensure => present }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
     end
 
     it 'reduce on enumerable type' do
@@ -42,7 +55,7 @@ describe 'the reduce method' do
         file { "/file_$b": ensure => present }
       MANIFEST
 
-      catalog.resource(:file, "/file_6")['ensure'].should == 'present'
+      expect(catalog).to have_resource("File[/file_6]").with_parameter(:ensure, 'present')
     end
 
     it 'reduce on an array with start value' do
@@ -52,8 +65,9 @@ describe 'the reduce method' do
         file { "/file_$b": ensure => present }
       MANIFEST
 
-      catalog.resource(:file, "/file_10")['ensure'].should == 'present'
+      expect(catalog).to have_resource("File[/file_10]").with_parameter(:ensure, 'present')
     end
+
     it 'reduce on a hash' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {a=>1, b=>2, c=>3}
@@ -62,8 +76,9 @@ describe 'the reduce method' do
         file { "/file_${$b[0]}_${$b[1]}": ensure => present }
       MANIFEST
 
-      catalog.resource(:file, "/file_sum_6")['ensure'].should == 'present'
+      expect(catalog).to have_resource("File[/file_sum_6]").with_parameter(:ensure, 'present')
     end
+
     it 'reduce on a hash with start value' do
       catalog = compile_to_catalog(<<-MANIFEST)
         $a = {a=>1, b=>2, c=>3}
@@ -72,7 +87,10 @@ describe 'the reduce method' do
         file { "/file_${$b[0]}_${$b[1]}": ensure => present }
       MANIFEST
 
-      catalog.resource(:file, "/file_sum_10")['ensure'].should == 'present'
+      expect(catalog).to have_resource("File[/file_sum_10]").with_parameter(:ensure, 'present')
     end
   end
+
+  it_should_behave_like 'all iterative functions argument checks', 'reduce'
+
 end

data/spec/unit/{parser/methods → functions}/slice_spec.rb

@@ -1,10 +1,11 @@
 require 'puppet'
 require 'spec_helper'
 require 'puppet_spec/compiler'
-require 'rubygems'
+require 'matchers/resource'
 
 describe 'methods' do
   include PuppetSpec::Compiler
+  include Matchers::Resource
 
   before :all do
     # enable switching back 
@@ -36,9 +37,22 @@ describe 'methods' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_2")['ensure'].should == 'absent'
-      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'absent')
+      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
+    end
+
+    it 'slice with captures last' do
+      catalog = compile_to_catalog(<<-MANIFEST)
+        $a = [1, present, 2, absent, 3, present]
+        $a.slice(2) |*$kv| {
+          file { "/file_${$kv[0]}": ensure => $kv[1] }
+        }
+      MANIFEST
+
+      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'absent')
+      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
     end
 
     it 'slice with one parameter' do
@@ -49,9 +63,9 @@ describe 'methods' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_2")['ensure'].should == 'absent'
-      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'absent')
+      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
     end
 
     it 'slice with shorter last slice' do
@@ -62,8 +76,8 @@ describe 'methods' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_1.2")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_3.")['ensure'].should == 'absent'
+      expect(catalog).to have_resource("File[/file_1.2]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_3.]").with_parameter(:ensure, 'absent')
     end
   end
 
@@ -76,8 +90,8 @@ describe 'methods' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_1.2")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_3.")['ensure'].should == 'absent'
+      expect(catalog).to have_resource("File[/file_1.2]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_3.]").with_parameter(:ensure, 'absent')
     end
   end
 
@@ -90,8 +104,8 @@ describe 'methods' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_1.2")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_3.4")['ensure'].should == 'present'
+      expect(catalog).to have_resource("File[/file_1.2]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_3.4]").with_parameter(:ensure, 'present')
     end
 
     it 'slice with integer' do
@@ -101,8 +115,8 @@ describe 'methods' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_0.1")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_2.3")['ensure'].should == 'present'
+      expect(catalog).to have_resource("File[/file_0.1]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_2.3]").with_parameter(:ensure, 'present')
     end
 
     it 'slice with string' do
@@ -112,8 +126,8 @@ describe 'methods' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_a.b")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_c.d")['ensure'].should == 'present'
+      expect(catalog).to have_resource("File[/file_a.b]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_c.d]").with_parameter(:ensure, 'present')
     end
   end
 
@@ -126,10 +140,9 @@ describe 'methods' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_2")['ensure'].should == 'absent'
-      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
-
+      expect(catalog).to have_resource("File[/file_1]").with_parameter(:ensure, 'present')
+      expect(catalog).to have_resource("File[/file_2]").with_parameter(:ensure, 'absent')
+      expect(catalog).to have_resource("File[/file_3]").with_parameter(:ensure, 'present')
     end
   end
 end

data/spec/unit/functions/with_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+require 'puppet_spec/compiler'
+require 'matchers/resource'
+
+describe 'the with function' do
+  include PuppetSpec::Compiler
+  include Matchers::Resource
+
+  before :each do
+    Puppet[:parser] = 'future'
+  end
+
+  it 'calls a lambda passing no arguments' do
+    expect(compile_to_catalog("with() || { notify { testing: } }")).to have_resource('Notify[testing]')
+  end
+
+  it 'calls a lambda passing a single argument' do
+    expect(compile_to_catalog('with(1) |$x| { notify { "testing$x": } }')).to have_resource('Notify[testing1]')
+  end
+
+  it 'calls a lambda passing more than one argument' do
+    expect(compile_to_catalog('with(1, 2) |*$x| { notify { "testing${x[0]}, ${x[1]}": } }')).to have_resource('Notify[testing1, 2]')
+  end
+
+  it 'passes a type reference to a lambda' do
+    expect(compile_to_catalog('notify { test: message => "data" } with(Notify[test]) |$x| { notify { "${x[message]}": } }')).to have_resource('Notify[data]')
+  end
+
+  it 'errors when not given enough arguments for the lambda' do
+    expect do
+      compile_to_catalog('with(1) |$x, $y| { }')
+    end.to raise_error(/Parameter \$y is required but no value was given/m)
+  end
+end

data/spec/unit/functions4_spec.rb

@@ -83,9 +83,9 @@ actual:
     func = f.new(:closure_scope, :loader)
     expect(func.is_a?(Puppet::Functions::Function)).to be_true
     signature = if RUBY_VERSION =~ /^1\.8/
-      'Object{2}'
+      'Any{2}'
     else
-      'Object x, Object y'
+      'Any x, Any y'
     end
     expect do
       func.call({}, 10)
@@ -102,9 +102,9 @@ actual:
     func = f.new(:closure_scope, :loader)
     expect(func.is_a?(Puppet::Functions::Function)).to be_true
     signature = if RUBY_VERSION =~ /^1\.8/
-      'Object{2}'
+      'Any{2}'
     else
-      'Object x, Object y'
+      'Any x, Any y'
     end
     expect do
       func.call({}, 10, 10, 10)
@@ -162,9 +162,9 @@ actual:
       func = f.new(:closure_scope, :loader)
       expect(func.is_a?(Puppet::Functions::Function)).to be_true
       signature = if RUBY_VERSION =~ /^1\.8/
-        'Object{2,}'
+        'Any{2,}'
       else
-        'Object x, Object y, Object a?, Object b?, Object c{0,}'
+        'Any x, Any y, Any a?, Any b?, Any c{0,}'
       end
       expect do
         func.call({}, 10)
@@ -439,12 +439,11 @@ actual:
         # about selection of parser and evaluator
         #
         Puppet[:parser] = 'future'
-        Puppet[:evaluator] = 'future'
         # Puppetx cannot be loaded until the correct parser has been set (injector is turned off otherwise)
         require 'puppetx'
       end
 
-      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 }
 

data/spec/unit/indirector/catalog/compiler_spec.rb

@@ -6,10 +6,8 @@ require 'puppet/rails'
 
 describe Puppet::Resource::Catalog::Compiler do
   before do
-    require 'puppet/rails'
     Puppet::Rails.stubs(:init)
     Facter.stubs(:to_hash).returns({})
-    Facter.stubs(:value).returns(Facter::Util::Fact.new("something"))
   end
 
   describe "when initializing" do

data/spec/unit/indirector/catalog/static_compiler_spec.rb

@@ -11,10 +11,21 @@ describe Puppet::Resource::Catalog::StaticCompiler do
   end
 
   before :each do
+    Facter.stubs(:loadfacts)
     Facter.stubs(:to_hash).returns({})
     Facter.stubs(:value)
   end
 
+  around(:each) do |example|
+    Puppet.override({
+        :current_environment => Puppet::Node::Environment.create(:app, []),
+      },
+      "Ensure we are using an environment other than root"
+    ) do
+      example.run
+    end
+  end
+
   let(:request) do
     Puppet::Indirector::Request.new(:the_indirection_named_foo,
                                     :find,

data/spec/unit/indirector/data_binding/hiera_spec.rb

@@ -2,34 +2,6 @@ require 'spec_helper'
 require 'puppet/indirector/data_binding/hiera'
 
 describe Puppet::DataBinding::Hiera do
-  include PuppetSpec::Files
-
-  def write_hiera_config(config_file, datadir)
-    File.open(config_file, 'w') do |f|
-      f.write("---
-        :yaml:
-          :datadir: #{datadir}
-        :hierarchy: ['global', 'invalid']
-        :logger: 'noop'
-        :backends: ['yaml']
-      ")
-    end
-  end
-
-  def request(key)
-    Puppet::Indirector::Request.new(:hiera, :find, key, nil)
-  end
-
-  before do
-    hiera_config_file = tmpfile("hiera.yaml")
-    Puppet.settings[:hiera_config] = hiera_config_file
-    write_hiera_config(hiera_config_file, my_fixture_dir)
-  end
-
-  after do
-    Puppet::DataBinding::Hiera.instance_variable_set(:@hiera, nil)
-  end
-
   it "should have documentation" do
     Puppet::DataBinding::Hiera.doc.should_not be_nil
   end
@@ -42,73 +14,6 @@ describe Puppet::DataBinding::Hiera do
   it "should have its name set to :hiera" do
     Puppet::DataBinding::Hiera.name.should == :hiera
   end
-  it "should be the default data_binding terminus" do
-    Puppet.settings[:data_binding_terminus].should == :hiera
-  end
-
-  it "should raise an error if we don't have the hiera feature" do
-    Puppet.features.expects(:hiera?).returns(false)
-    lambda { Puppet::DataBinding::Hiera.new }.should raise_error RuntimeError,
-      "Hiera terminus not supported without hiera library"
-  end
-
-  describe "the behavior of the hiera_config method", :if => Puppet.features.hiera? do
-    it "should override the logger and set it to puppet" do
-      Puppet::DataBinding::Hiera.hiera_config[:logger].should == "puppet"
-    end
 
-    context "when the Hiera configuration file does not exist" do
-      let(:path) { File.expand_path('/doesnotexist') }
-
-      before do
-        Puppet.settings[:hiera_config] = path
-      end
-
-      it "should log a warning" do
-        Puppet.expects(:warning).with(
-         "Config file #{path} not found, using Hiera defaults")
-        Puppet::DataBinding::Hiera.hiera_config
-      end
-
-      it "should only configure the logger and set it to puppet" do
-        Puppet.expects(:warning).with(
-         "Config file #{path} not found, using Hiera defaults")
-        Puppet::DataBinding::Hiera.hiera_config.should == { :logger => 'puppet' }
-      end
-    end
-  end
-
-  describe "the behavior of the find method", :if => Puppet.features.hiera? do
-
-    let(:data_binder) { Puppet::DataBinding::Hiera.new }
-
-    it "should support looking up an integer" do
-      data_binder.find(request("integer")).should == 3000
-    end
-
-    it "should support looking up a string" do
-      data_binder.find(request("string")).should == 'apache'
-    end
-
-    it "should support looking up an array" do
-      data_binder.find(request("array")).should == [
-        '0.ntp.puppetlabs.com',
-        '1.ntp.puppetlabs.com',
-      ]
-    end
-
-    it "should support looking up a hash" do
-      data_binder.find(request("hash")).should == {
-        'user'  => 'Hightower',
-        'group' => 'admin',
-        'mode'  => '0644'
-      }
-    end
-
-    it "raises a data binding error if hiera cannot parse the yaml data" do
-      expect do
-        data_binder.find(request('invalid'))
-      end.to raise_error(Puppet::DataBinding::LookupError)
-    end
-  end
+  it_should_behave_like "Hiera indirection", Puppet::DataBinding::Hiera, my_fixture_dir
 end