puppet 5.5.22-x64-mingw32 → 6.0.0-x64-mingw32

data/spec/unit/network/auth_config_parser_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/auth_config_parser'
 require 'puppet/network/authconfig'
@@ -47,52 +48,53 @@ describe Puppet::Network::AuthConfigParser do
     end
 
     it "should strip whitespace around ACE" do
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:allow).with('127.0.0.1')
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:allow).with('172.16.10.0')
+      Puppet::Network::Rights::Right.any_instance.expects(:allow).with('127.0.0.1')
+      Puppet::Network::Rights::Right.any_instance.expects(:allow).with('172.16.10.0')
 
       described_class.new("path /\n allow 127.0.0.1 , 172.16.10.0  ").parse_rights
     end
 
     it "should allow ACE inline comments" do
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:allow).with('127.0.0.1')
+
+      Puppet::Network::Rights::Right.any_instance.expects(:allow).with('127.0.0.1')
 
       described_class.new("path /\n allow 127.0.0.1 # will it work?").parse_rights
     end
 
     it "should create an allow ACE on each subsequent allow" do
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:allow).with('127.0.0.1')
+      Puppet::Network::Rights::Right.any_instance.expects(:allow).with('127.0.0.1')
 
       described_class.new("path /\nallow 127.0.0.1").parse_rights
     end
 
     it "should create a deny ACE on each subsequent deny" do
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:deny).with('127.0.0.1')
+      Puppet::Network::Rights::Right.any_instance.expects(:deny).with('127.0.0.1')
 
       described_class.new("path /\ndeny 127.0.0.1").parse_rights
     end
 
     it "should inform the current ACL if we get the 'method' directive" do
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:restrict_method).with('search')
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:restrict_method).with('find')
+      Puppet::Network::Rights::Right.any_instance.expects(:restrict_method).with('search')
+      Puppet::Network::Rights::Right.any_instance.expects(:restrict_method).with('find')
 
       described_class.new("path /certificates\nmethod search,find").parse_rights
     end
 
     it "should inform the current ACL if we get the 'environment' directive" do
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:restrict_environment).with('production')
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:restrict_environment).with('development')
+      Puppet::Network::Rights::Right.any_instance.expects(:restrict_environment).with('production')
+      Puppet::Network::Rights::Right.any_instance.expects(:restrict_environment).with('development')
 
       described_class.new("path /certificates\nenvironment production,development").parse_rights
     end
 
     it "should inform the current ACL if we get the 'auth' directive" do
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:restrict_authenticated).with('yes')
+      Puppet::Network::Rights::Right.any_instance.expects(:restrict_authenticated).with('yes')
 
       described_class.new("path /certificates\nauth yes").parse_rights
     end
 
     it "should also allow the long form 'authenticated' directive" do
-      expect_any_instance_of(Puppet::Network::Rights::Right).to receive(:restrict_authenticated).with('yes')
+      Puppet::Network::Rights::Right.any_instance.expects(:restrict_authenticated).with('yes')
 
       described_class.new("path /certificates\nauthenticated yes").parse_rights
     end

data/spec/unit/network/authconfig_spec.rb

@@ -1,26 +1,27 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/authconfig'
 
 describe Puppet::Network::DefaultAuthProvider do
   before :each do
-    allow(Puppet::FileSystem).to receive(:stat).and_return(double('stat', :ctime => :now))
-    allow(Time).to receive(:now).and_return(Time.now)
+    Puppet::FileSystem.stubs(:stat).returns stub('stat', :ctime => :now)
+    Time.stubs(:now).returns Time.now
 
-    allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:exists?).and_return(true)
+    Puppet::Network::DefaultAuthProvider.any_instance.stubs(:exists?).returns(true)
     # FIXME @authprovider = Puppet::Network::DefaultAuthProvider.new("dummy")
   end
 
   describe "when initializing" do
     it "inserts default ACLs after setting initial rights" do
-      expect_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.any_instance.expects(:insert_default_acl)
       Puppet::Network::DefaultAuthProvider.new
     end
   end
 
   describe "when defining an acl with mk_acl" do
     before :each do
-      allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.any_instance.stubs(:insert_default_acl)
       @authprovider = Puppet::Network::DefaultAuthProvider.new
     end
 
@@ -52,26 +53,26 @@ describe Puppet::Network::DefaultAuthProvider do
 
   describe "when adding default ACLs" do
     before :each do
-      allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:insert_default_acl)
+      Puppet::Network::DefaultAuthProvider.any_instance.stubs(:insert_default_acl)
       @authprovider = Puppet::Network::DefaultAuthProvider.new
-      allow_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:insert_default_acl).and_call_original
+      Puppet::Network::DefaultAuthProvider.any_instance.unstub(:insert_default_acl)
     end
 
     Puppet::Network::DefaultAuthProvider::default_acl.each do |acl|
       it "should create a default right for #{acl[:acl]}" do
-        allow(@authprovider).to receive(:mk_acl)
-        expect(@authprovider).to receive(:mk_acl).with(acl)
+        @authprovider.stubs(:mk_acl)
+        @authprovider.expects(:mk_acl).with(acl)
         @authprovider.insert_default_acl
       end
     end
 
     it "should log at info loglevel" do
-      expect(Puppet).to receive(:info).at_least(:once)
+      Puppet.expects(:info).at_least_once
       @authprovider.insert_default_acl
     end
 
     it "creates an empty catch-all rule for '/' for any authentication request state" do
-      allow(@authprovider).to receive(:mk_acl)
+      @authprovider.stubs(:mk_acl)
 
       @authprovider.insert_default_acl
       expect(@authprovider.rights['/']).to be_empty
@@ -85,8 +86,8 @@ describe Puppet::Network::DefaultAuthProvider do
         :allow => '$1',
         :authenticated => true
       }
-      allow(@authprovider).to receive(:mk_acl)
-      expect(@authprovider).to receive(:mk_acl).with(acl)
+      @authprovider.stubs(:mk_acl)
+      @authprovider.expects(:mk_acl).with(acl)
       @authprovider.insert_default_acl
     end
   end
@@ -100,7 +101,7 @@ describe Puppet::Network::DefaultAuthProvider do
         :authenticated => true
       }
 
-      expect_any_instance_of(Puppet::Network::Rights).to receive(:is_request_forbidden_and_why?).with(:save, "/path/to/resource", params)
+      Puppet::Network::Rights.any_instance.expects(:is_request_forbidden_and_why?).with(:save, "/path/to/resource", params)
 
       described_class.new.check_authorization(:save, "/path/to/resource", params)
     end
@@ -120,19 +121,19 @@ describe Puppet::Network::AuthConfig do
   it "instantiates authprovider_class with rights" do
     Puppet::Network::AuthConfig.authprovider_class = TestAuthProvider
     rights = Puppet::Network::Rights.new
-    expect(TestAuthProvider).to receive(:new).with(rights)
+    TestAuthProvider.expects(:new).with(rights)
     described_class.new(rights)
   end
 
   it "delegates authorization check to authprovider_class" do
     Puppet::Network::AuthConfig.authprovider_class = TestAuthProvider
-    expect_any_instance_of(TestAuthProvider).to receive(:check_authorization).with(:save, '/path/to/resource', {})
+    TestAuthProvider.any_instance.expects(:check_authorization).with(:save, '/path/to/resource', {})
     described_class.new.check_authorization(:save, '/path/to/resource', {})
   end
 
   it "uses DefaultAuthProvider by default" do
     Puppet::Network::AuthConfig.authprovider_class = nil
-    expect_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:check_authorization).with(:save, '/path/to/resource', {})
+    Puppet::Network::DefaultAuthProvider.any_instance.expects(:check_authorization).with(:save, '/path/to/resource', {})
     described_class.new.check_authorization(:save, '/path/to/resource', {})
   end
 end

data/spec/unit/network/authorization_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/network/http'
 require 'puppet/network/http/api/indirected_routes'
@@ -26,8 +27,8 @@ describe Puppet::Network::Authorization do
     end
 
     it "creates default ACL entries if no file has been read" do
-      expect(Puppet::Network::AuthConfigParser).to receive(:new_from_file).and_raise(Errno::ENOENT)
-      expect_any_instance_of(Puppet::Network::DefaultAuthProvider).to receive(:insert_default_acl)
+      Puppet::Network::AuthConfigParser.expects(:new_from_file).raises Errno::ENOENT
+      Puppet::Network::DefaultAuthProvider.any_instance.expects(:insert_default_acl)
 
       subject.authconfig
     end
@@ -51,8 +52,8 @@ describe Puppet::Network::Authorization do
     it "delegates to the authconfig object" do
       Puppet::Network::Authorization.authconfigloader_class =
           TestAuthConfigLoader
-      expect_any_instance_of(TestAuthConfig).to receive(:check_authorization).with(
-          :save, '/mypath', {:param1 => "value1"}).and_return("yay, it worked!")
+      TestAuthConfig.any_instance.expects(:check_authorization).with(
+          :save, '/mypath', {:param1 => "value1"}).returns("yay, it worked!")
       expect(subject.check_authorization(
                  :save, '/mypath',
                  {:param1 => "value1"})).to eq("yay, it worked!")

data/spec/unit/network/authstore_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'rbconfig'
 

data/spec/unit/network/format_handler_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/format_handler'

data/spec/unit/network/format_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/format'
@@ -75,7 +76,7 @@ describe Puppet::Network::Format do
     it "should consider a class supported if the provided class has all required methods present" do
       format = Puppet::Network::Format.new(:foo)
       [:intern_method, :intern_multiple_method, :render_multiple_method, :render_method].each do |method|
-        expect(format).to receive(:required_method_present?).with(method, String, anything).and_return(true)
+        format.expects(:required_method_present?).with { |name, klass, type| name == method and klass == String }.returns true
       end
 
       expect(format).to be_required_methods_present(String)
@@ -83,8 +84,8 @@ describe Puppet::Network::Format do
 
     it "should consider a class not supported if any required methods are missing from the provided class" do
       format = Puppet::Network::Format.new(:foo)
-      allow(format).to receive(:required_method_present?).and_return(true)
-      expect(format).to receive(:required_method_present?).with(:intern_method, anything, anything).and_return(false)
+      format.stubs(:required_method_present?).returns true
+      format.expects(:required_method_present?).with { |name, *args| name == :intern_method }.returns false
       expect(format).not_to be_required_methods_present(String)
     end
 
@@ -94,13 +95,13 @@ describe Puppet::Network::Format do
 
     it "should only test for required methods if specific methods are specified as required" do
       format = Puppet::Network::Format.new(:foo, :required_methods => [:intern_method])
-      expect(format).to receive(:required_method_present?).with(:intern_method, anything, anything)
+      format.expects(:required_method_present?).with { |name, klass, type| name == :intern_method }
 
       format.required_methods_present?(String)
     end
 
     it "should not consider a class supported unless the format is suitable" do
-      expect(@format).to receive(:suitable?).and_return(false)
+      @format.expects(:suitable?).returns false
       expect(@format).not_to be_supported(FormatRenderer)
     end
 
@@ -167,22 +168,22 @@ describe Puppet::Network::Format do
     end
 
     it "should return the results of calling the instance-specific render method if the method is present" do
-      expect(@instance).to receive(:to_my_format).and_return("foo")
+      @instance.expects(:to_my_format).returns "foo"
       expect(@format.render(@instance)).to eq("foo")
     end
 
     it "should return the results of calling the class-specific render_multiple method if the method is present" do
-      expect(@instance.class).to receive(:to_multiple_my_format).and_return(["foo"])
+      @instance.class.expects(:to_multiple_my_format).returns ["foo"]
       expect(@format.render_multiple([@instance])).to eq(["foo"])
     end
 
     it "should return the results of calling the class-specific intern method if the method is present" do
-      expect(FormatRenderer).to receive(:from_my_format).with("foo").and_return(@instance)
+      FormatRenderer.expects(:from_my_format).with("foo").returns @instance
       expect(@format.intern(FormatRenderer, "foo")).to equal(@instance)
     end
 
     it "should return the results of calling the class-specific intern_multiple method if the method is present" do
-      expect(FormatRenderer).to receive(:from_multiple_my_format).with("foo").and_return([@instance])
+      FormatRenderer.expects(:from_multiple_my_format).with("foo").returns [@instance]
       expect(@format.intern_multiple(FormatRenderer, "foo")).to eq([@instance])
     end
 

data/spec/unit/network/format_support_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/format_handler'
@@ -20,13 +21,13 @@ describe Puppet::Network::FormatHandler do
   describe "when listing formats" do
     before(:each) do
       one = Puppet::Network::FormatHandler.create(:one, :weight => 1)
-      allow(one).to receive(:supported?).and_return(true)
+      one.stubs(:supported?).returns(true)
       two = Puppet::Network::FormatHandler.create(:two, :weight => 6)
-      allow(two).to receive(:supported?).and_return(true)
+      two.stubs(:supported?).returns(true)
       three = Puppet::Network::FormatHandler.create(:three, :weight => 2)
-      allow(three).to receive(:supported?).and_return(true)
+      three.stubs(:supported?).returns(true)
       four = Puppet::Network::FormatHandler.create(:four, :weight => 8)
-      allow(four).to receive(:supported?).and_return(false)
+      four.stubs(:supported?).returns(false)
     end
 
     it "should return all supported formats in decreasing order of weight" do
@@ -35,16 +36,16 @@ describe Puppet::Network::FormatHandler do
   end
 
   it "should return the first format as the default format" do
-    expect(FormatTester).to receive(:supported_formats).and_return [:one, :two]
+    FormatTester.expects(:supported_formats).returns [:one, :two]
     expect(FormatTester.default_format).to eq(:one)
   end
 
   describe "with a preferred serialization format setting" do
     before do
       one = Puppet::Network::FormatHandler.create(:one, :weight => 1)
-      allow(one).to receive(:supported?).and_return(true)
+      one.stubs(:supported?).returns(true)
       two = Puppet::Network::FormatHandler.create(:two, :weight => 6)
-      allow(two).to receive(:supported?).and_return(true)
+      two.stubs(:supported?).returns(true)
     end
 
     describe "that is supported" do
@@ -67,8 +68,8 @@ describe Puppet::Network::FormatHandler do
       end
 
       it "should log a debug message" do
-        expect(Puppet).to receive(:debug).with("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)")
-        expect(Puppet).to receive(:debug).with("FormatTester supports formats: two one")
+        Puppet.expects(:debug).with("Value of 'preferred_serialization_format' (unsupported) is invalid for FormatTester, using default (two)")
+        Puppet.expects(:debug).with("FormatTester supports formats: two one")
         FormatTester.supported_formats
       end
     end
@@ -78,27 +79,27 @@ describe Puppet::Network::FormatHandler do
     let(:format) { Puppet::Network::FormatHandler.create(:my_format, :mime => "text/myformat") }
 
     it "should use the Format to determine whether a given format is supported" do
-      expect(format).to receive(:supported?).with(FormatTester)
+      format.expects(:supported?).with(FormatTester)
       FormatTester.support_format?(:my_format)
     end
 
     it "should call the format-specific converter when asked to convert from a given format" do
-      expect(format).to receive(:intern).with(FormatTester, "mydata")
+      format.expects(:intern).with(FormatTester, "mydata")
       FormatTester.convert_from(:my_format, "mydata")
     end
 
     it "should call the format-specific converter when asked to convert from a given format by mime-type" do
-      expect(format).to receive(:intern).with(FormatTester, "mydata")
+      format.expects(:intern).with(FormatTester, "mydata")
       FormatTester.convert_from("text/myformat", "mydata")
     end
 
     it "should call the format-specific converter when asked to convert from a given format by format instance" do
-      expect(format).to receive(:intern).with(FormatTester, "mydata")
+      format.expects(:intern).with(FormatTester, "mydata")
       FormatTester.convert_from(format, "mydata")
     end
 
     it "should raise a FormatError when an exception is encountered when converting from a format" do
-      expect(format).to receive(:intern).with(FormatTester, "mydata").and_raise("foo")
+      format.expects(:intern).with(FormatTester, "mydata").raises "foo"
       expect do
         FormatTester.convert_from(:my_format, "mydata")
       end.to raise_error(
@@ -108,26 +109,26 @@ describe Puppet::Network::FormatHandler do
     end
 
     it "should be able to use a specific hook for converting into multiple instances" do
-      expect(format).to receive(:intern_multiple).with(FormatTester, "mydata")
+      format.expects(:intern_multiple).with(FormatTester, "mydata")
 
       FormatTester.convert_from_multiple(:my_format, "mydata")
     end
 
     it "should raise a FormatError when an exception is encountered when converting multiple items from a format" do
-      expect(format).to receive(:intern_multiple).with(FormatTester, "mydata").and_raise("foo")
+      format.expects(:intern_multiple).with(FormatTester, "mydata").raises "foo"
       expect do
         FormatTester.convert_from_multiple(:my_format, "mydata")
       end.to raise_error(Puppet::Network::FormatHandler::FormatError, 'Could not intern_multiple from my_format: foo')
     end
 
     it "should be able to use a specific hook for rendering multiple instances" do
-      expect(format).to receive(:render_multiple).with("mydata")
+      format.expects(:render_multiple).with("mydata")
 
       FormatTester.render_multiple(:my_format, "mydata")
     end
 
     it "should raise a FormatError when an exception is encountered when rendering multiple items into a format" do
-      expect(format).to receive(:render_multiple).with("mydata").and_raise("foo")
+      format.expects(:render_multiple).with("mydata").raises "foo"
       expect do
         FormatTester.render_multiple(:my_format, "mydata")
       end.to raise_error(Puppet::Network::FormatHandler::FormatError, 'Could not render_multiple to my_format: foo')
@@ -138,13 +139,13 @@ describe Puppet::Network::FormatHandler do
     let(:format) { Puppet::Network::FormatHandler.create(:foo, :mime => "text/foo") }
 
     it "should list as supported a format that reports itself supported" do
-      expect(format).to receive(:supported?).and_return(true)
+      format.expects(:supported?).returns true
       expect(FormatTester.new.support_format?(:foo)).to be_truthy
     end
 
     it "should raise a FormatError when a rendering error is encountered" do
       tester = FormatTester.new
-      expect(format).to receive(:render).with(tester).and_raise("eh")
+      format.expects(:render).with(tester).raises "eh"
 
       expect do
         tester.render(:foo)
@@ -153,45 +154,45 @@ describe Puppet::Network::FormatHandler do
 
     it "should call the format-specific converter when asked to convert to a given format" do
       tester = FormatTester.new
-      expect(format).to receive(:render).with(tester).and_return("foo")
+      format.expects(:render).with(tester).returns "foo"
 
       expect(tester.render(:foo)).to eq("foo")
     end
 
     it "should call the format-specific converter when asked to convert to a given format by mime-type" do
       tester = FormatTester.new
-      expect(format).to receive(:render).with(tester).and_return("foo")
+      format.expects(:render).with(tester).returns "foo"
 
       expect(tester.render("text/foo")).to eq("foo")
     end
 
     it "should call the format converter when asked to convert to a given format instance" do
       tester = FormatTester.new
-      expect(format).to receive(:render).with(tester).and_return("foo")
+      format.expects(:render).with(tester).returns "foo"
 
       expect(tester.render(format)).to eq("foo")
     end
 
     it "should render to the default format if no format is provided when rendering" do
-      expect(FormatTester).to receive(:default_format).and_return(:foo)
+      FormatTester.expects(:default_format).returns :foo
       tester = FormatTester.new
 
-      expect(format).to receive(:render).with(tester)
+      format.expects(:render).with(tester)
       tester.render
     end
 
     it "should call the format-specific converter when asked for the mime-type of a given format" do
       tester = FormatTester.new
-      expect(format).to receive(:mime).and_return("text/foo")
+      format.expects(:mime).returns "text/foo"
 
       expect(tester.mime(:foo)).to eq("text/foo")
     end
 
     it "should return the default format mime-type if no format is provided" do
-      expect(FormatTester).to receive(:default_format).and_return(:foo)
+      FormatTester.expects(:default_format).returns :foo
       tester = FormatTester.new
 
-      expect(format).to receive(:mime).and_return("text/foo")
+      format.expects(:mime).returns "text/foo"
       expect(tester.mime).to eq("text/foo")
     end
   end