puppet 3.8.7 → 4.0.0

data/spec/unit/forge/repository_spec.rb

@@ -40,7 +40,7 @@ describe Puppet::Forge::Repository do
         http.expects(:request).with(responds_with(:path, "the_path"))
       end
 
-      repository.make_http_request("the_path").should == result
+      expect(repository.make_http_request("the_path")).to eq(result)
     end
 
     it 'returns the result object from a request with ssl' do
@@ -49,7 +49,7 @@ describe Puppet::Forge::Repository do
         http.expects(:request).with(responds_with(:path, "the_path"))
       end
 
-      ssl_repository.make_http_request("the_path").should == result
+      expect(ssl_repository.make_http_request("the_path")).to eq(result)
     end
 
     it 'return a valid exception when there is an SSL verification problem' do
@@ -75,23 +75,23 @@ describe Puppet::Forge::Repository do
 
       request = repository.get_request_object(path)
 
-      request['User-Agent'].should =~ /\b#{agent}\b/
-      request['User-Agent'].should =~ /\bPuppet\b/
-      request['User-Agent'].should =~ /\bRuby\b/
+      expect(request['User-Agent']).to match(/\b#{agent}\b/)
+      expect(request['User-Agent']).to match(/\bPuppet\b/)
+      expect(request['User-Agent']).to match(/\bRuby\b/)
     end
 
     it "Does not set Authorization header by default" do
       Puppet.features.stubs(:pe_license?).returns(false)
       Puppet[:forge_authorization] = nil
       request = repository.get_request_object("the_path")
-      request['Authorization'].should == nil
+      expect(request['Authorization']).to eq(nil)
     end
 
     it "Sets Authorization header from config" do
       token = 'bearer some token'
       Puppet[:forge_authorization] = token
       request = repository.get_request_object("the_path")
-      request['Authorization'].should == token
+      expect(request['Authorization']).to eq(token)
     end
 
     it "escapes the received URI" do
@@ -104,29 +104,18 @@ describe Puppet::Forge::Repository do
     end
 
     def performs_an_http_request(result = nil, &block)
-      http = mock("http client")
-      yield http
-
-      proxy_class = mock("http proxy class")
-      proxy = mock("http proxy")
-      proxy_class.expects(:new).with("fake.com", 80).returns(proxy)
-      proxy.expects(:start).yields(http).returns(result)
-      Net::HTTP.expects(:Proxy).with("proxy", 1234, nil, nil).returns(proxy_class)
+      proxy_args = ["proxy", 1234, nil, nil]
+      mock_proxy(80, proxy_args, result, &block)
     end
 
     def performs_an_https_request(result = nil, &block)
-      http = mock("http client")
-      yield http
-
-      proxy_class = mock("http proxy class")
-      proxy = mock("http proxy")
-      proxy_class.expects(:new).with("fake.com", 443).returns(proxy)
-      proxy.expects(:start).yields(http).returns(result)
+      proxy_args = ["proxy", 1234, nil, nil]
+      proxy = mock_proxy(443, proxy_args, result, &block)
       proxy.expects(:use_ssl=).with(true)
       proxy.expects(:cert_store=)
       proxy.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
-      Net::HTTP.expects(:Proxy).with("proxy", 1234, nil, nil).returns(proxy_class)
     end
+
   end
 
   describe "making a request against an authentiated proxy" do
@@ -141,7 +130,7 @@ describe Puppet::Forge::Repository do
         http.expects(:request).with(responds_with(:path, "the_path"))
       end
 
-      repository.make_http_request("the_path").should == result
+      expect(repository.make_http_request("the_path")).to eq(result)
     end
 
     it 'returns the result object from a request with ssl' do
@@ -150,7 +139,7 @@ describe Puppet::Forge::Repository do
         http.expects(:request).with(responds_with(:path, "the_path"))
       end
 
-      ssl_repository.make_http_request("the_path").should == result
+      expect(ssl_repository.make_http_request("the_path")).to eq(result)
     end
 
     it 'return a valid exception when there is an SSL verification problem' do
@@ -176,9 +165,9 @@ describe Puppet::Forge::Repository do
 
       request = repository.get_request_object(path)
 
-      request['User-Agent'].should =~ /\b#{agent}\b/
-      request['User-Agent'].should =~ /\bPuppet\b/
-      request['User-Agent'].should =~ /\bRuby\b/
+      expect(request['User-Agent']).to match(/\b#{agent}\b/)
+      expect(request['User-Agent']).to match(/\bPuppet\b/)
+      expect(request['User-Agent']).to match(/\bRuby\b/)
     end
 
     it "escapes the received URI" do
@@ -191,28 +180,16 @@ describe Puppet::Forge::Repository do
     end
 
     def performs_an_authenticated_http_request(result = nil, &block)
-      http = mock("http client")
-      yield http
-
-      proxy_class = mock("http proxy class")
-      proxy = mock("http proxy")
-      proxy_class.expects(:new).with("fake.com", 80).returns(proxy)
-      proxy.expects(:start).yields(http).returns(result)
-      Net::HTTP.expects(:Proxy).with("proxy", 1234, "user1", "password").returns(proxy_class)
+      proxy_args = ["proxy", 1234, 'user1', 'password']
+      mock_proxy(80, proxy_args, result, &block)
     end
 
     def performs_an_authenticated_https_request(result = nil, &block)
-      http = mock("http client")
-      yield http
-
-      proxy_class = mock("http proxy class")
-      proxy = mock("http proxy")
-      proxy_class.expects(:new).with("fake.com", 443).returns(proxy)
-      proxy.expects(:start).yields(http).returns(result)
+      proxy_args = ["proxy", 1234, 'user1', 'password']
+      proxy = mock_proxy(443, proxy_args, result, &block)
       proxy.expects(:use_ssl=).with(true)
       proxy.expects(:cert_store=)
       proxy.expects(:verify_mode=).with(OpenSSL::SSL::VERIFY_PEER)
-      Net::HTTP.expects(:Proxy).with("proxy", 1234, "user1", "password").returns(proxy_class)
     end
   end
 
@@ -227,4 +204,21 @@ describe Puppet::Forge::Repository do
     Puppet[:http_proxy_user] = user
     Puppet[:http_proxy_password] = password
   end
+
+  def mock_proxy(port, proxy_args, result, &block)
+    http = mock("http client")
+    proxy = mock("http proxy")
+    proxy_class = mock("http proxy class")
+
+    Net::HTTP.expects(:Proxy).with(*proxy_args).returns(proxy_class)
+    proxy_class.expects(:new).with("fake.com", port).returns(proxy)
+
+    proxy.expects(:open_timeout=)
+    proxy.expects(:read_timeout=)
+
+    proxy.expects(:start).yields(http).returns(result)
+    yield http
+
+    proxy
+  end
 end

data/spec/unit/forge_spec.rb

@@ -107,7 +107,7 @@ describe Puppet::Forge do
 
   it "returns a list of matches from the forge when there are matches for the search term" do
     repository_responds_with(stub(:body => http_response, :code => '200'))
-    forge.search('bacula').should == search_results
+    expect(forge.search('bacula')).to eq(search_results)
   end
 
   context "when module_groups are defined" do

data/spec/unit/functions/assert_type_spec.rb

@@ -19,7 +19,7 @@ describe 'the assert_type function' do
   it 'asserts non compliant type by raising an error' do
     expect do
       func.call({}, type(Integer), 'hello world')
-    end.to raise_error(Puppet::ParseError, /does not match actual/)
+    end.to raise_error(Puppet::Pops::Types::TypeAssertionError, /does not match actual/)
   end
 
   it 'checks that first argument is a type' do

data/spec/unit/functions/each_spec.rb

@@ -7,10 +7,6 @@ require 'shared_behaviours/iterative_functions'
 describe 'the each method' do
   include PuppetSpec::Compiler
 
-  before :each do
-    Puppet[:parser] = 'future'
-  end
-
   context "should be callable as" do
     it 'each on an array selecting each value' do
       catalog = compile_to_catalog(<<-MANIFEST)
@@ -20,9 +16,9 @@ describe 'the each method' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_2")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+      expect(catalog.resource(:file, "/file_1")['ensure']).to eq('present')
+      expect(catalog.resource(:file, "/file_2")['ensure']).to eq('present')
+      expect(catalog.resource(:file, "/file_3")['ensure']).to eq('present')
     end
 
     it 'each on an array selecting each value - function call style' do
@@ -33,9 +29,9 @@ describe 'the each method' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_1")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_2")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+      expect(catalog.resource(:file, "/file_1")['ensure']).to eq('present')
+      expect(catalog.resource(:file, "/file_2")['ensure']).to eq('present')
+      expect(catalog.resource(:file, "/file_3")['ensure']).to eq('present')
     end
 
     it 'each on an array with index' do
@@ -46,9 +42,9 @@ describe 'the each method' 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.resource(:file, "/file_1")['ensure']).to eq('present')
+      expect(catalog.resource(:file, "/file_2")['ensure']).to eq('absent')
+      expect(catalog.resource(:file, "/file_3")['ensure']).to eq('present')
     end
 
     it 'each on a hash selecting entries' do
@@ -59,9 +55,9 @@ describe 'the each method' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_a")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_b")['ensure'].should == 'absent'
-      catalog.resource(:file, "/file_c")['ensure'].should == 'present'
+      expect(catalog.resource(:file, "/file_a")['ensure']).to eq('present')
+      expect(catalog.resource(:file, "/file_b")['ensure']).to eq('absent')
+      expect(catalog.resource(:file, "/file_c")['ensure']).to eq('present')
     end
 
     it 'each on a hash selecting key and value' do
@@ -72,9 +68,9 @@ describe 'the each method' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_a")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_b")['ensure'].should == 'absent'
-      catalog.resource(:file, "/file_c")['ensure'].should == 'present'
+      expect(catalog.resource(:file, "/file_a")['ensure']).to eq('present')
+      expect(catalog.resource(:file, "/file_b")['ensure']).to eq('absent')
+      expect(catalog.resource(:file, "/file_c")['ensure']).to eq('present')
     end
 
     it 'each on a hash selecting key and value (using captures-last parameter)' do
@@ -85,9 +81,9 @@ describe 'the each method' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_a")['ensure'].should == 'present'
-      catalog.resource(:file, "/file_b")['ensure'].should == 'absent'
-      catalog.resource(:file, "/file_c")['ensure'].should == 'present'
+      expect(catalog.resource(:file, "/file_a")['ensure']).to eq('present')
+      expect(catalog.resource(:file, "/file_b")['ensure']).to eq('absent')
+      expect(catalog.resource(:file, "/file_c")['ensure']).to eq('present')
     end
   end
 
@@ -101,7 +97,7 @@ describe 'the each method' do
         }
       MANIFEST
 
-      catalog.resource(:file, "/file_3")['ensure'].should == 'present'
+      expect(catalog.resource(:file, "/file_3")['ensure']).to eq('present')
     end
 
   end

data/spec/unit/functions/epp_spec.rb

@@ -3,14 +3,6 @@ require 'spec_helper'
 describe "the epp function" do
   include PuppetSpec::Files
 
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    Puppet[:parser] = 'future'
-  end
-
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
   let :scope    do Puppet::Parser::Scope.new(compiler) end
@@ -18,35 +10,35 @@ describe "the epp function" do
   context "when accessing scope variables as $ variables" do
     it "looks up the value from the scope" do
       scope["what"] = "are belong"
-      eval_template("all your base <%= $what %> to us").should == "all your base are belong to us"
+      expect(eval_template("all your base <%= $what %> to us")).to eq("all your base are belong to us")
     end
 
     it "get nil accessing a variable that does not exist" do
-      eval_template("<%= $kryptonite == undef %>").should == "true"
+      expect(eval_template("<%= $kryptonite == undef %>")).to eq("true")
     end
 
     it "get nil accessing a variable that is undef" do
       scope['undef_var'] = nil
-      eval_template("<%= $undef_var == undef %>").should == "true"
+      expect(eval_template("<%= $undef_var == undef %>")).to eq("true")
     end
 
     it "gets shadowed variable if args are given" do
       scope['phantom'] = 'of the opera'
-      eval_template_with_args("<%= $phantom == dragos %>", 'phantom' => 'dragos').should == "true"
+      expect(eval_template_with_args("<%= $phantom == dragos %>", 'phantom' => 'dragos')).to eq("true")
     end
 
     it "can use values from the enclosing scope for defaults" do
       scope['phantom'] = 'of the opera'
-      eval_template("<%- |$phantom = $phantom| -%><%= $phantom %>").should == "of the opera"
+      expect(eval_template("<%- |$phantom = $phantom| -%><%= $phantom %>")).to eq("of the opera")
     end
 
     it "uses the default value if the given value is undef/nil" do
-      eval_template_with_args("<%- |$phantom = 'inside your mind'| -%><%= $phantom %>", 'phantom' => nil).should == "inside your mind"
+      expect(eval_template_with_args("<%- |$phantom = 'inside your mind'| -%><%= $phantom %>", 'phantom' => nil)).to eq("inside your mind")
     end
 
     it "gets shadowed variable if args are given and parameters are specified" do
       scope['x'] = 'wrong one'
-      eval_template_with_args("<%- |$x| -%><%= $x == correct %>", 'x' => 'correct').should == "true"
+      expect(eval_template_with_args("<%- |$x| -%><%= $x == correct %>", 'x' => 'correct')).to eq("true")
     end
 
     it "raises an error if required variable is not given" do
@@ -106,12 +98,12 @@ describe "the epp function" do
   # although never a problem with epp
   it "is not interfered with by having a variable named 'string' (#14093)" do
     scope['string'] = "this output should not be seen"
-    eval_template("some text that is static").should == "some text that is static"
+    expect(eval_template("some text that is static")).to eq("some text that is static")
   end
 
   it "has access to a variable named 'string' (#14093)" do
     scope['string'] = "the string value"
-    eval_template("string was: <%= $string %>").should == "string was: the string value"
+    expect(eval_template("string was: <%= $string %>")).to eq("string was: the string value")
   end
 
   describe 'when loading from modules' do

data/spec/unit/functions/filter_spec.rb

@@ -9,10 +9,6 @@ describe 'the filter method' do
   include PuppetSpec::Compiler
   include Matchers::Resource
 
-  before :each do
-    Puppet[:parser] = 'future'
-  end
-
   it 'should filter on an array (all berries)' do
     catalog = compile_to_catalog(<<-MANIFEST)
       $a = ['strawberry','blueberry','orange']
@@ -126,24 +122,6 @@ describe 'the filter method' do
     expect(catalog).to have_resource("File[/file_blueb]").with_parameter(:ensure, 'present')
   end
 
-  it 'filters on an array will not include elements for which the block returns truthy but not true' do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      $r = [1, 2, 3].filter |$v| { $v } == []
-      notify { "eval_${$r}": }
-    MANIFEST
-
-    expect(catalog).to have_resource('Notify[eval_true]')
-  end
-
-  it 'filters on a hash will not include elements for which the block returns truthy but not true' do
-    catalog = compile_to_catalog(<<-MANIFEST)
-      $r = {a => 1, b => 2, c => 3}.filter |$k, $v| { $v } == {}
-      notify { "eval_${$r}": }
-    MANIFEST
-
-    expect(catalog).to have_resource('Notify[eval_true]')
-  end
-
   it_should_behave_like 'all iterative functions argument checks', 'filter'
   it_should_behave_like 'all iterative functions hash handling', 'filter'
 end

data/spec/unit/functions/hiera_spec.rb

@@ -22,38 +22,32 @@ describe 'when calling' do
     end
 
     it 'should use the priority resolution_type' do
-      Hiera.any_instance.expects(:lookup).with { |*args| args[4].should be(:priority) }.returns('foo_result')
+      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[4]).to be(:priority) }.returns('foo_result')
       expect(hiera.call(scope, 'key')).to eql('foo_result')
     end
 
+    it 'should propagate optional default' do
+      dflt = 'the_default'
+      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[1]).to be(dflt) }.returns('foo_result')
+      expect(hiera.call(scope, 'key', dflt)).to eql('foo_result')
+    end
+
     it 'should propagate optional override' do
       ovr = 'the_override'
-      Hiera.any_instance.expects(:lookup).with { |*args| args[3].should be(ovr) }.returns('foo_result')
+      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[3]).to be(ovr) }.returns('foo_result')
       expect(hiera.call(scope, 'key', nil, ovr)).to eql('foo_result')
     end
 
-    it 'should return default value nil when key is not found' do
-       expect(hiera.call(scope, 'foo', nil)).to be_nil
-    end
-
-    it "should return default value '' when key is not found" do
-      expect(hiera.call(scope, 'foo', '')).to eq('')
-    end
-
     it 'should use default block' do
       #expect(hiera.call(scope, 'foo', lambda_1(scope, loader) { |k| "default for key '#{k}'" })).to eql("default for key 'foo'")
       expect(hiera.call(scope, 'foo') { |k| "default for key '#{k}'" }).to eql("default for key 'foo'")
     end
 
-    # Test disabled since it assumes that Yaml_backend returns nil when a key is not found and that this
-    # triggers use of default. This changes in Hiera 2.0 so that the backend throws a :no_such_key exception.
-    # Changing that here will invalidate tests using hiera stable.
-    #
-    # it 'should propagate optional override when combined with default block' do
-    #   ovr = 'the_override'
-    #   Hiera::Backend::Yaml_backend.any_instance.expects(:lookup).with { |*args| args[2].should be(ovr) }
-    #   expect(hiera.call(scope, 'foo', ovr) { |k| "default for key '#{k}'" }).to eql("default for key 'foo'")
-    # end
+    it 'should propagate optional override when combined with default block' do
+      ovr = {}
+      Hiera::Backend::Yaml_backend.any_instance.expects(:lookup).with { |*args| expect(args[2]).to be(ovr) }.returns(nil)
+      expect(hiera.call(scope, 'foo.bar', ovr) { |k| "default for key '#{k}'" }).to eql("default for key 'foo.bar'")
+    end
   end
 
   context 'hiera_array' do
@@ -69,7 +63,7 @@ describe 'when calling' do
     end
 
     it 'should use the array resolution_type' do
-      Hiera.any_instance.expects(:lookup).with { |*args| args[4].should be(:array) }.returns(%w[foo bar baz])
+      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[4]).to be(:array) }.returns(%w[foo bar baz])
       expect(hiera_array.call(scope, 'key', {'key' => 'foo_result'})).to eql(%w[foo bar baz])
     end
 
@@ -90,7 +84,7 @@ describe 'when calling' do
     end
 
     it 'should use the hash resolution_type' do
-      Hiera.any_instance.expects(:lookup).with { |*args| args[4].should be(:hash) }.returns({'foo' => 'result'})
+      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[4]).to be(:hash) }.returns({'foo' => 'result'})
       expect(hiera_hash.call(scope, 'key', {'key' => 'foo_result'})).to eql({'foo' => 'result'})
     end
 
@@ -111,8 +105,8 @@ describe 'when calling' do
     end
 
     it 'should use the array resolution_type' do
-      Hiera.any_instance.expects(:lookup).with { |*args| args[4].should be(:array) }.returns(%w[foo bar baz])
-      hiera_include.expects(:call_function_with_scope).with(scope, 'include', %w[foo bar baz])
+      Hiera.any_instance.expects(:lookup).with { |*args| expect(args[4]).to be(:array) }.returns(%w[foo bar baz])
+      hiera_include.expects(:call_function).with('include', %w[foo bar baz])
       hiera_include.call(scope, 'key', {'key' => 'foo_result'})
     end
 
@@ -122,7 +116,7 @@ describe 'when calling' do
     end
 
     it 'should use default block' do
-      hiera_include.expects(:call_function_with_scope).with(scope,'include', %w[key foo])
+      hiera_include.expects(:call_function).with('include', %w[key foo])
       hiera_include.call(scope, 'foo') { |k| ['key', k] }
     end
   end

data/spec/unit/functions/inline_epp_spec.rb

@@ -4,14 +4,6 @@ require 'spec_helper'
 describe "the inline_epp function" do
   include PuppetSpec::Files
 
-  before :all do
-    Puppet::Parser::Functions.autoloader.loadall
-  end
-
-  before :each do
-    Puppet[:parser] = 'future'
-  end
-
   let :node     do Puppet::Node.new('localhost') end
   let :compiler do Puppet::Parser::Compiler.new(node) end
   let :scope    do Puppet::Parser::Scope.new(compiler) end
@@ -19,26 +11,26 @@ describe "the inline_epp function" do
   context "when accessing scope variables as $ variables" do
     it "looks up the value from the scope" do
       scope["what"] = "are belong"
-      eval_template("all your base <%= $what %> to us").should == "all your base are belong to us"
+      expect(eval_template("all your base <%= $what %> to us")).to eq("all your base are belong to us")
     end
 
     it "get nil accessing a variable that does not exist" do
-      eval_template("<%= $kryptonite == undef %>").should == "true"
+      expect(eval_template("<%= $kryptonite == undef %>")).to eq("true")
     end
 
     it "get nil accessing a variable that is undef" do
       scope['undef_var'] = :undef
-      eval_template("<%= $undef_var == undef %>").should == "true"
+      expect(eval_template("<%= $undef_var == undef %>")).to eq("true")
     end
 
     it "gets shadowed variable if args are given" do
       scope['phantom'] = 'of the opera'
-      eval_template_with_args("<%= $phantom == dragos %>", 'phantom' => 'dragos').should == "true"
+      expect(eval_template_with_args("<%= $phantom == dragos %>", 'phantom' => 'dragos')).to eq("true")
     end
 
     it "gets shadowed variable if args are given and parameters are specified" do
       scope['x'] = 'wrong one'
-      eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct').should == "true"
+      expect(eval_template_with_args("<%-| $x |-%><%= $x == correct %>", 'x' => 'correct')).to eq("true")
     end
 
     it "raises an error if required variable is not given" do
@@ -67,18 +59,18 @@ describe "the inline_epp function" do
   end
 
   it "renders a block expression" do
-    eval_template_with_args("<%= { $y = $x $x + 1} %>", 'x' => 2).should == "3"
+    expect(eval_template_with_args("<%= { $y = $x $x + 1} %>", 'x' => 2)).to eq("3")
   end
 
   # although never a problem with epp
   it "is not interfered with by having a variable named 'string' (#14093)" do
     scope['string'] = "this output should not be seen"
-    eval_template("some text that is static").should == "some text that is static"
+    expect(eval_template("some text that is static")).to eq("some text that is static")
   end
 
   it "has access to a variable named 'string' (#14093)" do
     scope['string'] = "the string value"
-    eval_template("string was: <%= $string %>").should == "string was: the string value"
+    expect(eval_template("string was: <%= $string %>")).to eq("string was: the string value")
   end