puppet 3.8.7 → 4.0.0.rc1

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

@@ -6,146 +6,9 @@ require 'puppet_spec/scope'
 describe "lookup function" do
   include PuppetSpec::Scope
 
-  before(:each) do
-    Puppet[:binder] = true
-    Puppet[:parser] = 'future'
-  end
-
-  it "must be called with at least a name to lookup" do
-    scope = scope_with_injections_from(bound(bindings))
-
-    expect do
-      scope.function_lookup([])
-    end.to raise_error(ArgumentError, /Wrong number of arguments/)
-
-    expect do
-      scope.function_lookup([1,2])
-    end.to raise_error(Puppet::ParseError, /given 'name' argument, has wrong type/)
-  end
-
-  it "looks up a value that exists" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['a_value'])).to eq('something')
-  end
-
-  it "searches for first found if given several names" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup([['b_value', 'a_value', 'c_value']])).to eq('something')
-  end
-
-  it "override wins over bound" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    options = {:override => { 'a_value' => 'something_overridden' }}
-    expect(scope.function_lookup(['a_value', options])).to eq('something_overridden')
-  end
-
-  it "extra option is used if nothing is found" do
-    scope = scope_with_injections_from(bound(bind_single("another_value", "something")))
-    options = {:extra => { 'a_value' => 'something_extra' }}
-    expect(scope.function_lookup(['a_value', options])).to eq('something_extra')
-  end
-
-  it "hiera is called to lookup if value is not bound" do
-    Hiera.any_instance.stubs(:lookup).returns('from_hiera')
-    scope = scope_with_injections_from(bound(bind_single("another_value", "something")))
-    expect(scope.function_lookup(['a_value'])).to eq('from_hiera')
-  end
-
-  it "returns nil when the requested value is not bound and undef is accepted" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['not_bound_value',{'accept_undef' => true}])).to eq(nil)
-  end
-
-  it "fails if the requested value is not bound and undef is not allowed" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect do
-      scope.function_lookup(['not_bound_value'])
-    end.to raise_error(/did not find a value for the name 'not_bound_value'/)
-  end
-
-  it "returns the given default value when the requested value is not bound" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['not_bound_value','String', 'cigar'])).to eq('cigar')
-  end
-
-  it "accepts values given in a hash of options" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['not_bound_value',{'type' => 'String', 'default' => 'cigar'}])).to eq('cigar')
-  end
-
-  it "raises an error when the bound type is not assignable to the requested type" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect do
-      scope.function_lookup(['a_value', 'Integer'])
-    end.to raise_error(ArgumentError, /incompatible type, expected: Integer, got: String/)
-  end
-
-  it "returns the value if the bound type is assignable to the requested type" do
-    typed_bindings = bindings
-    typed_bindings.bind().string().name("a_value").to("something")
-    scope = scope_with_injections_from(bound(typed_bindings))
-    expect(scope.function_lookup(['a_value', 'Data'])).to eq("something")
-  end
-
-  it "yields to a given lambda and returns the result" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['a_value', ast_lambda(scope, '|$x|{something_else}')])).to eq('something_else')
-  end
-
-  it "fails if given lambda produces undef" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect do
-      scope.function_lookup(['a_value', ast_lambda(scope, '|$x|{undef}')])
-    end.to raise_error(/did not find a value for the name 'a_value'/)
-  end
-
-  it "yields name and result to a given lambda" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['a_value', ast_lambda(scope, '|$name, $result|{[$name, $result]}')])).to eq(['a_value', 'something'])
-  end
-
-  it "yields name and result and default to a given lambda" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['a_value', {'default' => 'cigar'}, 
-      ast_lambda(scope, '|$name, $result, $d|{[$name, $result, $d]}')])).to eq(['a_value', 'something', 'cigar'])
-  end
-
-  it "yields to a given lambda and returns the result when giving name and type" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['a_value', 'String', ast_lambda(scope, '|$x|{something_else}')])).to eq('something_else')
-  end
-
-  it "yields :undef when value is not found and using a lambda" do
-    scope = scope_with_injections_from(bound(bind_single("a_value", "something")))
-    expect(scope.function_lookup(['not_bound_value', ast_lambda(scope, '|$x|{ if $x == undef {good} else {bad}}')])).to eq('good')
-  end
-
-  def scope_with_injections_from(binder)
-    injector = Puppet::Pops::Binder::Injector.new(binder)
-    scope = create_test_scope_for_node('testing')
-    scope.compiler.injector = injector
-    scope
-  end
-
-  def bindings
-    Puppet::Pops::Binder::BindingsFactory.named_bindings("testing")
-  end
-
-  def bind_single(name, value)
-    local_bindings = Puppet::Pops::Binder::BindingsFactory.named_bindings("testing")
-    local_bindings.bind().name(name).to(value)
-    local_bindings
-  end
-
-  def bound(local_bindings)
-    layered_bindings = Puppet::Pops::Binder::BindingsFactory.layered_bindings(Puppet::Pops::Binder::BindingsFactory.named_layer('test layer', local_bindings.model))
-    Puppet::Pops::Binder::Binder.new(layered_bindings)
-  end
+  let :scope do create_test_scope_for_node('foo') end
 
-  def ast_lambda(scope, puppet_source)
-    puppet_source = "fake_func() " + puppet_source
-    evaluator = Puppet::Pops::Parser::EvaluatingParser.new()
-    model = evaluator.parse_string(puppet_source, __FILE__).current
-    evaluator.closure(model.body.lambda, scope)
+  it 'should raise an error since this function is converted to 4x API)' do
+    expect { scope.function_lookup(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
   end
 end

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

@@ -12,185 +12,13 @@ describe "the regsubst function" do
     @scope   = Puppet::Parser::Scope.new(compiler)
   end
 
-  it "should exist" do
-    Puppet::Parser::Functions.function("regsubst").should == "function_regsubst"
-  end
-
-  it "should raise an ArgumentError if there is less than 3 arguments" do
-    lambda { @scope.function_regsubst(["foo", "bar"]) }.should( raise_error(ArgumentError))
-  end
-
-  it "should raise an ArgumentError if there is more than 5 arguments" do
-    lambda { @scope.function_regsubst(["foo", "bar", "gazonk", "del", "x", "y"]) }.should( raise_error(ArgumentError))
-  end
-
-
-  it "should raise a ParseError when given a bad flag" do
-    lambda { @scope.function_regsubst(["foo", "bar", "gazonk", "X"]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError for non-string and non-array target" do
-    lambda { @scope.function_regsubst([4711, "bar", "gazonk"]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError for array target with non-string element" do
-    lambda { @scope.function_regsubst([["x", ["y"], "z"], "bar", "gazonk"]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError for a bad regular expression" do
-    lambda { @scope.function_regsubst(["foo", "(bar", "gazonk"]) }.should(
-      raise_error(Puppet::ParseError))
-  end
-
-  it "should raise a ParseError for a non-string regular expression" do
-    lambda { @scope.function_regsubst(["foo", ["bar"], "gazonk"]) }.should( raise_error(Puppet::ParseError))
-  end
-
-  it "should handle groups" do
-
-    result = @scope.function_regsubst(
-
-      [ '130.236.254.10',
-
-        '^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$',
-        '\4-\3-\2-\1'
-      ])
-    result.should(eql("10-254-236-130"))
-  end
-
-  it "should handle simple regexps" do
-
-    result = @scope.function_regsubst(
-
-      [ "the monkey breaks banana trees",
-        "b[an]*a",
-
-        "coconut"
-      ])
-    result.should(eql("the monkey breaks coconut trees"))
-  end
-
-  it "should handle case-sensitive regexps" do
-
-    result = @scope.function_regsubst(
-
-      [ "the monkey breaks baNAna trees",
-        "b[an]+a",
-
-        "coconut"
-      ])
-    result.should(eql("the monkey breaks baNAna trees"))
-  end
-
-  it "should handle case-insensitive regexps" do
-
-    result = @scope.function_regsubst(
-
-      [ "the monkey breaks baNAna trees",
-        "b[an]+a",
-        "coconut",
-
-        "I"
-      ])
-      result.should(eql("the monkey breaks coconut trees"))
-  end
-
-  it "should handle global substitutions" do
-
-    result = @scope.function_regsubst(
-
-      [ "the monkey breaks\tbanana trees",
-        "[ \t]",
-        "--",
-
-        "G"
+  it 'should raise an ParseError' do
+    expect do
+      @scope.function_regsubst(
+      [ 'the monkey breaks banana trees',
+        'b[an]*a',
+        'coconut'
       ])
-    result.should(eql("the--monkey--breaks--banana--trees"))
-  end
-
-  it "should handle global substitutions with groups" do
-
-    result = @scope.function_regsubst(
-
-      [ '130.236.254.10',
-
-        '([0-9]+)',
-        '<\1>',
-        'G'
-      ])
-    result.should(eql('<130>.<236>.<254>.<10>'))
-  end
-
-  it "should apply on all elements of an array" do
-    data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
-    result = @scope.function_regsubst([ data, '[.]', '-'])
-    result.should(eql( ['130-236.254.10', 'foo-example.com', 'coconut', '10-20.30.40']))
+    end.to raise_error(Puppet::ParseError, /converted to 4x API/)
   end
-
-  it "should apply global substitutions on all elements of an array" do
-    data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
-    result = @scope.function_regsubst([ data, '[.]', '-', 'G'])
-    result.should(eql( ['130-236-254-10', 'foo-example-com', 'coconut', '10-20-30-40']))
-  end
-
-  it "should handle groups on all elements of an array" do
-    data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
-
-      result = @scope.function_regsubst(
-
-        [ data,
-
-        '^([0-9]+)[.]([0-9]+)[.]([0-9]+)[.]([0-9]+)$',
-        '\4-\3-\2-\1'
-      ])
-    result.should(eql( ['10-254-236-130', 'foo.example.com', 'coconut', '40-30-20-10']))
-  end
-
-  it "should handle global substitutions with groups on all elements of an array" do
-    data = ['130.236.254.10', 'foo.example.com', 'coconut', '10.20.30.40']
-
-      result = @scope.function_regsubst(
-
-        [ data,
-
-        '([^.]+)',
-        '<\1>',
-        'G'
-      ])
-
-        result.should(eql(
-
-          ['<130>.<236>.<254>.<10>', '<foo>.<example>.<com>',
-
-      '<coconut>', '<10>.<20>.<30>.<40>']))
-  end
-
-  it "should return an array (not a string) for a single element array parameter" do
-    data = ['130.236.254.10']
-
-      result = @scope.function_regsubst(
-
-        [ data,
-
-        '([^.]+)',
-        '<\1>',
-        'G'
-      ])
-    result.should(eql(['<130>.<236>.<254>.<10>']))
-  end
-
-  it "should return a string (not a one element array) for a simple string parameter" do
-    data = '130.236.254.10'
-
-      result = @scope.function_regsubst(
-
-        [ data,
-
-        '([^.]+)',
-        '<\1>',
-        'G'
-      ])
-    result.should(eql('<130>.<236>.<254>.<10>'))
-  end
-
 end

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

@@ -1,11 +1,13 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'unit/parser/functions/shared'
+require 'puppet_spec/compiler'
 
 describe "the require function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
+  include PuppetSpec::Compiler
+#  before :all do
+#    Puppet::Parser::Functions.autoloader.loadall
+#  end
 
   before :each do
     @catalog = stub 'catalog'
@@ -23,11 +25,11 @@ describe "the require function" do
   end
 
   it "should exist" do
-    Puppet::Parser::Functions.function("require").should == "function_require"
+    expect(Puppet::Parser::Functions.function("require")).to eq("function_require")
   end
 
   it "should delegate to the 'include' puppet function" do
-    @scope.compiler.expects(:evaluate_classes).with(["myclass"], @scope, false)
+    @scope.compiler.expects(:evaluate_classes).with(["::myclass"], @scope, false)
 
     @scope.function_require(["myclass"])
   end
@@ -36,14 +38,14 @@ describe "the require function" do
     @scope.compiler.stubs(:evaluate_classes)
     @scope.function_require(["myclass"])
 
-    @resource["require"].should be_instance_of(Array)
-    @resource["require"][0].should be_instance_of(Puppet::Resource)
+    expect(@resource["require"]).to be_instance_of(Array)
+    expect(@resource["require"][0]).to be_instance_of(Puppet::Resource)
   end
 
   it "should lookup the absolute class path" do
     @scope.compiler.stubs(:evaluate_classes)
 
-    @scope.expects(:find_hostclass).with("myclass").returns(@klass)
+    @scope.expects(:find_hostclass).with("::myclass").returns(@klass)
     @klass.expects(:name).returns("myclass")
 
     @scope.function_require(["myclass"])
@@ -56,20 +58,11 @@ describe "the require function" do
     @resource[:require] = one
     @scope.function_require(["myclass"])
 
-    @resource[:require].should be_include(one)
-    @resource[:require].detect { |r| r.to_s == "Class[Myclass]" }.should be_instance_of(Puppet::Resource)
+    expect(@resource[:require]).to be_include(one)
+    expect(@resource[:require].detect { |r| r.to_s == "Class[Myclass]" }).to 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
 
-    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/shellquote_spec.rb

@@ -7,61 +7,61 @@ describe "the shellquote function" do
   let :scope    do Puppet::Parser::Scope.new(compiler) end
 
   it "should exist" do
-    Puppet::Parser::Functions.function("shellquote").should == "function_shellquote"
+    expect(Puppet::Parser::Functions.function("shellquote")).to eq("function_shellquote")
   end
 
   it "should handle no arguments" do
-    scope.function_shellquote([]).should == ""
+    expect(scope.function_shellquote([])).to eq("")
   end
 
   it "should handle several simple arguments" do
-    scope.function_shellquote(
+    expect(scope.function_shellquote(
       ['foo', 'bar@example.com', 'localhost:/dev/null', 'xyzzy+-4711,23']
-    ).should == 'foo bar@example.com localhost:/dev/null xyzzy+-4711,23'
+    )).to eq('foo bar@example.com localhost:/dev/null xyzzy+-4711,23')
   end
 
   it "should handle array arguments" do
-    scope.function_shellquote(
+    expect(scope.function_shellquote(
       ['foo', ['bar@example.com', 'localhost:/dev/null'],
       'xyzzy+-4711,23']
-    ).should == 'foo bar@example.com localhost:/dev/null xyzzy+-4711,23'
+    )).to eq('foo bar@example.com localhost:/dev/null xyzzy+-4711,23')
   end
 
   it "should quote unsafe characters" do
-    scope.function_shellquote(['/etc/passwd ', '(ls)', '*', '[?]', "'&'"]).
-      should == '"/etc/passwd " "(ls)" "*" "[?]" "\'&\'"'
+    expect(scope.function_shellquote(['/etc/passwd ', '(ls)', '*', '[?]', "'&'"])).
+      to eq('"/etc/passwd " "(ls)" "*" "[?]" "\'&\'"')
   end
 
   it "should deal with double quotes" do
-    scope.function_shellquote(['"foo"bar"']).should == '\'"foo"bar"\''
+    expect(scope.function_shellquote(['"foo"bar"'])).to eq('\'"foo"bar"\'')
   end
 
   it "should cope with dollar signs" do
-    scope.function_shellquote(['$PATH', 'foo$bar', '"x$"']).
-      should == "'$PATH' 'foo$bar' '\"x$\"'"
+    expect(scope.function_shellquote(['$PATH', 'foo$bar', '"x$"'])).
+      to eq("'$PATH' 'foo$bar' '\"x$\"'")
   end
 
   it "should deal with apostrophes (single quotes)" do
-    scope.function_shellquote(["'foo'bar'", "`$'EDITOR'`"]).
-      should == '"\'foo\'bar\'" "\\`\\$\'EDITOR\'\\`"'
+    expect(scope.function_shellquote(["'foo'bar'", "`$'EDITOR'`"])).
+      to eq('"\'foo\'bar\'" "\\`\\$\'EDITOR\'\\`"')
   end
 
   it "should cope with grave accents (backquotes)" do
-    scope.function_shellquote(['`echo *`', '`ls "$MAILPATH"`']).
-      should == "'`echo *`' '`ls \"$MAILPATH\"`'"
+    expect(scope.function_shellquote(['`echo *`', '`ls "$MAILPATH"`'])).
+      to eq("'`echo *`' '`ls \"$MAILPATH\"`'")
   end
 
   it "should deal with both single and double quotes" do
-    scope.function_shellquote(['\'foo"bar"xyzzy\'', '"foo\'bar\'xyzzy"']).
-      should == '"\'foo\\"bar\\"xyzzy\'" "\\"foo\'bar\'xyzzy\\""'
+    expect(scope.function_shellquote(['\'foo"bar"xyzzy\'', '"foo\'bar\'xyzzy"'])).
+      to eq('"\'foo\\"bar\\"xyzzy\'" "\\"foo\'bar\'xyzzy\\""')
   end
 
   it "should handle multiple quotes *and* dollars and backquotes" do
-    scope.function_shellquote(['\'foo"$x`bar`"xyzzy\'']).
-      should == '"\'foo\\"\\$x\\`bar\\`\\"xyzzy\'"'
+    expect(scope.function_shellquote(['\'foo"$x`bar`"xyzzy\''])).
+      to eq('"\'foo\\"\\$x\\`bar\\`\\"xyzzy\'"')
   end
 
   it "should handle linefeeds" do
-    scope.function_shellquote(["foo \n bar"]).should == "\"foo \n bar\""
+    expect(scope.function_shellquote(["foo \n bar"])).to eq("\"foo \n bar\"")
   end
 end