puppet 3.8.7-x86-mingw32 → 4.0.0.rc1-x86-mingw32

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

@@ -13,13 +13,13 @@ describe "the digest function", :uses_checksums => true do
   end
 
   it "should exist" do
-    Puppet::Parser::Functions.function("digest").should == "function_digest"
+    expect(Puppet::Parser::Functions.function("digest")).to eq("function_digest")
   end
 
   with_digest_algorithms do
     it "should use the proper digest function" do
       result = @scope.function_digest([plaintext])
-      result.should(eql( checksum ))
+      expect(result).to(eql( checksum ))
     end
 
     it "should only accept one parameter" do

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

@@ -15,7 +15,7 @@ describe "the 'fail' parser function" do
   end
 
   it "should exist" do
-    Puppet::Parser::Functions.function(:fail).should == "function_fail"
+    expect(Puppet::Parser::Functions.function(:fail)).to eq("function_fail")
   end
 
   it "should raise a parse error if invoked" do

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

@@ -15,7 +15,7 @@ describe "the 'file' function" do
 
   def with_file_content(content)
     path = tmpfile('file-function')
-    file = File.new(path, 'wb')
+    file = File.new(path, 'w')
     file.sync = true
     file.print content
     yield path
@@ -27,26 +27,20 @@ describe "the 'file' function" do
     end
   end
 
-  it "should read a file keeping line endings intact" do
-    with_file_content("file content\r\n") do |name|
-      expect(scope.function_file([name])).to eq("file content\r\n")
-    end
-  end
-
   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'
+      expect(scope.function_file(['mymod/myfile'])).to eq('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"
+        expect(scope.function_file([one, two])).to eq("one")
       end
     end
   end
@@ -59,7 +53,7 @@ describe "the 'file' function" do
         mod.expects(:file).with('one').returns(one)
         mod.stubs(:file).with('two').returns(two)
 
-        scope.function_file(['mymod/one','mymod/two']).should == 'one'
+        expect(scope.function_file(['mymod/one','mymod/two'])).to eq('one')
       end
     end
   end
@@ -71,7 +65,7 @@ describe "the 'file' function" do
         compiler.environment.stubs(:module).with('mymod').returns(mod)
         mod.stubs(:file).with('two').returns(two)
 
-        scope.function_file([one,'mymod/two']).should == 'one'
+        expect(scope.function_file([one,'mymod/two'])).to eq('one')
       end
     end
   end
@@ -83,7 +77,7 @@ describe "the 'file' function" do
         compiler.environment.expects(:module).with('mymod').returns(mod)
         mod.stubs(:file).with('two').returns(two)
 
-        scope.function_file(['mymod/two',one]).should == 'two'
+        expect(scope.function_file(['mymod/two',one])).to eq('two')
       end
     end
   end
@@ -91,7 +85,7 @@ describe "the 'file' function" do
   it "should not fail when some files are absent" do
     expect {
       with_file_content('one') do |one|
-        scope.function_file([make_absolute("/should-not-exist"), one]).should == 'one'
+        expect(scope.function_file([make_absolute("/should-not-exist"), one])).to eq('one')
       end
     }.to_not raise_error
   end

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

@@ -6,32 +6,32 @@ describe "the fqdn_rand function" do
   include PuppetSpec::Scope
   
   it "provides a random number strictly less than the given max" do
-    fqdn_rand(3).should satisfy {|n| n.to_i < 3 }
+    expect(fqdn_rand(3)).to satisfy {|n| n.to_i < 3 }
   end
 
   it "provides the same 'random' value on subsequent calls for the same host" do
-    fqdn_rand(3).should eql(fqdn_rand(3))
+    expect(fqdn_rand(3)).to eql(fqdn_rand(3))
   end
 
   it "considers the same host and same extra arguments to have the same random sequence" do
     first_random = fqdn_rand(3, :extra_identifier => [1, "same", "host"])
     second_random = fqdn_rand(3, :extra_identifier => [1, "same", "host"])
 
-    first_random.should eql(second_random)
+    expect(first_random).to eql(second_random)
   end
 
   it "allows extra arguments to control the random value on a single host" do
     first_random = fqdn_rand(10000, :extra_identifier => [1, "different", "host"])
     second_different_random = fqdn_rand(10000, :extra_identifier => [2, "different", "host"])
 
-    first_random.should_not eql(second_different_random)
+    expect(first_random).not_to eql(second_different_random)
   end
 
   it "should return different sequences of value for different hosts" do
     val1 = fqdn_rand(1000000000, :host => "first.host.com")
     val2 = fqdn_rand(1000000000, :host => "second.host.com")
 
-    val1.should_not eql(val2)
+    expect(val1).not_to eql(val2)
   end
 
   def fqdn_rand(max, args = {})

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

@@ -13,81 +13,81 @@ describe "the generate function" do
   let :scope    do Puppet::Parser::Scope.new(compiler) end
 
   it "should exist" do
-    Puppet::Parser::Functions.function("generate").should == "function_generate"
+    expect(Puppet::Parser::Functions.function("generate")).to eq("function_generate")
   end
 
   it "accept a fully-qualified path as a command" do
     command = File.expand_path('/command/foo')
     Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
-    scope.function_generate([command]).should == "yay"
+    expect(scope.function_generate([command])).to eq("yay")
   end
 
   it "should not accept a relative path as a command" do
-    lambda { scope.function_generate(["command"]) }.should raise_error(Puppet::ParseError)
+    expect { scope.function_generate(["command"]) }.to raise_error(Puppet::ParseError)
   end
 
   it "should not accept a command containing illegal characters" do
-    lambda { scope.function_generate([File.expand_path('/##/command')]) }.should raise_error(Puppet::ParseError)
+    expect { scope.function_generate([File.expand_path('/##/command')]) }.to raise_error(Puppet::ParseError)
   end
 
   it "should not accept a command containing spaces" do
-    lambda { scope.function_generate([File.expand_path('/com mand')]) }.should raise_error(Puppet::ParseError)
+    expect { scope.function_generate([File.expand_path('/com mand')]) }.to raise_error(Puppet::ParseError)
   end
 
   it "should not accept a command containing '..'" do
     command = File.expand_path("/command/../")
-    lambda { scope.function_generate([command]) }.should raise_error(Puppet::ParseError)
+    expect { scope.function_generate([command]) }.to raise_error(Puppet::ParseError)
   end
 
   it "should execute the generate script with the correct working directory" do
     command = File.expand_path("/command")
     Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
-    scope.function_generate([command]).should == 'yay'
+    expect(scope.function_generate([command])).to eq('yay')
   end
 
   describe "on Windows", :if => Puppet.features.microsoft_windows? do
     it "should accept the tilde in the path" do
       command = "C:/DOCUME~1/ADMINI~1/foo.bat"
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
-      scope.function_generate([command]).should == 'yay'
+      expect(scope.function_generate([command])).to eq('yay')
     end
 
     it "should accept lower-case drive letters" do
       command = 'd:/command/foo'
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
-      scope.function_generate([command]).should == 'yay'
+      expect(scope.function_generate([command])).to eq('yay')
     end
 
     it "should accept upper-case drive letters" do
       command = 'D:/command/foo'
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
-      scope.function_generate([command]).should == 'yay'
+      expect(scope.function_generate([command])).to eq('yay')
     end
 
     it "should accept forward and backslashes in the path" do
       command = 'D:\command/foo\bar'
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
-      scope.function_generate([command]).should == 'yay'
+      expect(scope.function_generate([command])).to eq('yay')
     end
 
     it "should reject colons when not part of the drive letter" do
-      lambda { scope.function_generate(['C:/com:mand']) }.should raise_error(Puppet::ParseError)
+      expect { scope.function_generate(['C:/com:mand']) }.to raise_error(Puppet::ParseError)
     end
 
     it "should reject root drives" do
-      lambda { scope.function_generate(['C:/']) }.should raise_error(Puppet::ParseError)
+      expect { scope.function_generate(['C:/']) }.to raise_error(Puppet::ParseError)
     end
   end
 
-  describe "on non-Windows", :as_platform => :posix do
+  describe "on POSIX", :if => Puppet.features.posix? do
     it "should reject backslashes" do
-      lambda { scope.function_generate(['/com\\mand']) }.should raise_error(Puppet::ParseError)
+      expect { scope.function_generate(['/com\\mand']) }.to raise_error(Puppet::ParseError)
     end
 
     it "should accept plus and dash" do
       command = "/var/folders/9z/9zXImgchH8CZJh6SgiqS2U+++TM/-Tmp-/foo"
       Dir.expects(:chdir).with(File.dirname(command)).returns("yay")
-      scope.function_generate([command]).should == 'yay'
+      expect(scope.function_generate([command])).to eq('yay')
     end
   end
 
@@ -111,19 +111,19 @@ describe "the generate function" do
   end
 
   it "returns the output as a String" do
-    scope.function_generate([command]).class.should == String
+    expect(scope.function_generate([command]).class).to eq(String)
   end
 
   it "should call generator with no arguments" do
-    scope.function_generate([command]).should == "a- b-\n"
+    expect(scope.function_generate([command])).to eq("a- b-\n")
   end
 
   it "should call generator with one argument" do
-    scope.function_generate([command, 'one']).should == "a-one b-\n"
+    expect(scope.function_generate([command, 'one'])).to eq("a-one b-\n")
   end
 
   it "should call generator with wo arguments" do
-    scope.function_generate([command, 'one', 'two']).should == "a-one b-two\n"
+    expect(scope.function_generate([command, 'one', 'two'])).to eq("a-one b-two\n")
   end
 
   it "should fail if generator is not absolute" do

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

@@ -4,23 +4,9 @@ require 'puppet_spec/scope'
 describe 'Puppet::Parser::Functions#hiera_array' do
   include PuppetSpec::Scope
 
-  before :each do
-    Puppet[:hiera_config] = PuppetSpec::Files.tmpfile('hiera_config')
-  end
-
   let :scope do create_test_scope_for_node('foo') end
 
-  it 'should require a key argument' do
-    expect { scope.function_hiera_array([]) }.to raise_error(ArgumentError)
-  end
-
-  it 'should raise a useful error when nil is returned' do
-    Hiera.any_instance.expects(:lookup).returns(nil)
-    expect { scope.function_hiera_array(["badkey"]) }.to raise_error(Puppet::ParseError, /Could not find data item badkey/ )
-  end
-
-  it 'should use the array resolution_type' do
-    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be(:array) }.returns([])
-    scope.function_hiera_array(['key'])
+  it 'should raise an error since this function is converted to 4x API)' do
+    expect { scope.function_hiera_array(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
   end
 end

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

@@ -6,17 +6,7 @@ describe 'Puppet::Parser::Functions#hiera_hash' do
 
   let :scope do create_test_scope_for_node('foo') end
 
-  it 'should require a key argument' do
-    expect { scope.function_hiera_hash([]) }.to raise_error(ArgumentError)
-  end
-
-  it 'should raise a useful error when nil is returned' do
-    Hiera.any_instance.expects(:lookup).returns(nil)
-    expect { scope.function_hiera_hash(["badkey"]) }.to raise_error(Puppet::ParseError, /Could not find data item badkey/ )
-  end
-
-  it 'should use the hash resolution_type' do
-    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be :hash }.returns({})
-    scope.function_hiera_hash(['key'])
+  it 'should raise an error since this function is converted to 4x API)' do
+    expect { scope.function_hiera_hash(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
   end
 end

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

@@ -6,34 +6,7 @@ describe 'Puppet::Parser::Functions#hiera_include' do
 
   let :scope do create_test_scope_for_node('foo') end
 
-  before :each do
-    Puppet[:hiera_config] = PuppetSpec::Files.tmpfile('hiera_config')
-  end
-
-  it 'should require a key argument' do
-    expect { scope.function_hiera_include([]) }.to raise_error(ArgumentError)
-  end
-
-  it 'should raise a useful error when nil is returned' do
-    HieraPuppet.expects(:lookup).returns(nil)
-    expect { scope.function_hiera_include(["badkey"]) }.
-      to raise_error(Puppet::ParseError, /Could not find data item badkey/ )
-  end
-
-  it 'should use the array resolution_type' do
-    HieraPuppet.expects(:lookup).with() { |*args| args[4].should be(:array) }.returns(['someclass'])
-    expect { scope.function_hiera_include(['key']) }.to raise_error(Puppet::Error, /Could not find class someclass/)
-  end
-
-  it 'should call the `include` function with the classes' do
-    HieraPuppet.expects(:lookup).returns %w[foo bar baz]
-
-    scope.expects(:function_include).with([%w[foo bar baz]])
-    scope.function_hiera_include(['key'])
-  end
-
-  it 'should not raise an error if the resulting hiera lookup returns an empty array' do
-    HieraPuppet.expects(:lookup).returns []
-    expect { scope.function_hiera_include(['key']) }.to_not raise_error
+  it 'should raise an error since this function is converted to 4x API)' do
+    expect { scope.function_hiera_include(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
   end
 end

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

@@ -6,17 +6,7 @@ describe 'Puppet::Parser::Functions#hiera' do
 
   let :scope do create_test_scope_for_node('foo') end
 
-  it 'should require a key argument' do
-    expect { scope.function_hiera([]) }.to raise_error(ArgumentError)
-  end
-
-  it 'should raise a useful error when nil is returned' do
-    Hiera.any_instance.expects(:lookup).returns(nil)
-    expect { scope.function_hiera(["badkey"]) }.to raise_error(Puppet::ParseError, /Could not find data item badkey/ )
-  end
-
-  it 'should use the priority resolution_type' do
-    Hiera.any_instance.expects(:lookup).with() { |*args| args[4].should be(:priority) }.returns('foo_result')
-    scope.function_hiera(['key']).should == 'foo_result'
+  it 'should raise an error since this function is converted to 4x API)' do
+    expect { scope.function_hiera(['key']) }.to raise_error(Puppet::ParseError, /converted to 4x API/)
   end
 end

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

@@ -1,11 +1,10 @@
 #! /usr/bin/env ruby
 require 'spec_helper'
 require 'unit/parser/functions/shared'
+require 'puppet_spec/compiler'
 
 describe "the 'include' function" do
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
+  include PuppetSpec::Compiler
 
   before :each do
     @compiler = Puppet::Parser::Compiler.new(Puppet::Node.new("foo"))
@@ -13,29 +12,29 @@ describe "the 'include' function" do
   end
 
   it "should exist" do
-    Puppet::Parser::Functions.function("include").should == "function_include"
+    expect(Puppet::Parser::Functions.function("include")).to eq("function_include")
   end
 
   it "should include a single class" do
-    inc = "foo"
+    inc = "::foo"
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == [inc]}.returns([inc])
     @scope.function_include(["foo"])
   end
 
   it "should include multiple classes" do
-    inc = ["foo","bar"]
+    inc = ["::foo","::bar"]
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == inc}.returns(inc)
     @scope.function_include(["foo","bar"])
   end
 
   it "should include multiple classes passed in an array" do
-    inc = ["foo","bar"]
+    inc = ["::foo","::bar"]
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == inc}.returns(inc)
     @scope.function_include([["foo","bar"]])
   end
 
   it "should flatten nested arrays" do
-    inc = ["foo","bar","baz"]
+    inc = ["::foo","::bar","::baz"]
     @compiler.expects(:evaluate_classes).with {|klasses,parser,lazy| klasses == inc}.returns(inc)
     @scope.function_include([["foo","bar"],"baz"])
   end
@@ -50,16 +49,7 @@ describe "the 'include' function" do
     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
 
-    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/inline_template_spec.rb

@@ -11,7 +11,7 @@ describe "the inline_template function" do
   let(:scope) { Puppet::Parser::Scope.new(compiler) }
 
   it "should concatenate template wrapper outputs for multiple templates" do
-    inline_template("template1", "template2").should == "template1template2"
+    expect(inline_template("template1", "template2")).to eq("template1template2")
   end
 
   it "should raise an error if the template raises an error" do
@@ -20,12 +20,12 @@ describe "the inline_template function" do
 
   it "is not interfered with by a variable called 'string' (#14093)" do
     scope['string'] = "this is a variable"
-    inline_template("this is a template").should == "this is a template"
+    expect(inline_template("this is a template")).to eq("this is a template")
   end
 
   it "has access to a variable called 'string' (#14093)" do
     scope['string'] = "this is a variable"
-    inline_template("string was: <%= @string %>").should == "string was: this is a variable"
+    expect(inline_template("string was: <%= @string %>")).to eq("string was: this is a variable")
   end
 
   def inline_template(*templates)