puppet 6.4.0-x86-mingw32 → 6.4.1-x86-mingw32

data/spec/unit/network/rights_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/network/rights'
@@ -118,58 +117,58 @@ describe Puppet::Network::Rights do
 
   describe "when checking if right is allowed" do
     before :each do
-      @right.stubs(:right).returns(nil)
+      allow(@right).to receive(:right).and_return(nil)
 
-      @pathacl = stub 'pathacl', :"<=>" => 1, :line => 0, :file => 'dummy'
-      Puppet::Network::Rights::Right.stubs(:new).returns(@pathacl)
+      @pathacl = double('pathacl', :"<=>" => 1, :line => 0, :file => 'dummy')
+      allow(Puppet::Network::Rights::Right).to receive(:new).and_return(@pathacl)
     end
 
     it "should delegate to is_forbidden_and_why?" do
-      @right.expects(:is_forbidden_and_why?).with("namespace", :node => "host.domain.com", :ip => "127.0.0.1").returns(nil)
+      expect(@right).to receive(:is_forbidden_and_why?).with("namespace", :node => "host.domain.com", :ip => "127.0.0.1").and_return(nil)
 
       @right.allowed?("namespace", "host.domain.com", "127.0.0.1")
     end
 
     it "should return true if is_forbidden_and_why? returns nil" do
-      @right.stubs(:is_forbidden_and_why?).returns(nil)
+      allow(@right).to receive(:is_forbidden_and_why?).and_return(nil)
       expect(@right.allowed?("namespace", :args)).to be_truthy
     end
 
     it "should return false if is_forbidden_and_why? returns an AuthorizationError" do
-      @right.stubs(:is_forbidden_and_why?).returns(Puppet::Network::AuthorizationError.new("forbidden"))
+      allow(@right).to receive(:is_forbidden_and_why?).and_return(Puppet::Network::AuthorizationError.new("forbidden"))
       expect(@right.allowed?("namespace", :args1, :args2)).to be_falsey
     end
 
     it "should pass the match? return to allowed?" do
       @right.newright("/path/to/there")
 
-      @pathacl.expects(:match?).returns(:match)
-      @pathacl.expects(:allowed?).with { |node,ip,h| h[:match] == :match }.returns(true)
+      expect(@pathacl).to receive(:match?).and_return(:match)
+      expect(@pathacl).to receive(:allowed?).with(anything, anything, hash_including(match: :match)).and_return(true)
 
       expect(@right.is_forbidden_and_why?("/path/to/there", {})).to eq(nil)
     end
 
     describe "with path acls" do
       before :each do
-        @long_acl = stub 'longpathacl', :name => "/path/to/there", :line => 0, :file => 'dummy'
-        Puppet::Network::Rights::Right.stubs(:new).with("/path/to/there", 0, nil).returns(@long_acl)
+        @long_acl = double('longpathacl', :name => "/path/to/there", :line => 0, :file => 'dummy')
+        allow(Puppet::Network::Rights::Right).to receive(:new).with("/path/to/there", 0, nil).and_return(@long_acl)
 
-        @short_acl = stub 'shortpathacl', :name => "/path/to", :line => 0, :file => 'dummy'
-        Puppet::Network::Rights::Right.stubs(:new).with("/path/to", 0, nil).returns(@short_acl)
+        @short_acl = double('shortpathacl', :name => "/path/to", :line => 0, :file => 'dummy')
+        allow(Puppet::Network::Rights::Right).to receive(:new).with("/path/to", 0, nil).and_return(@short_acl)
 
-        @long_acl.stubs(:"<=>").with(@short_acl).returns(0)
-        @short_acl.stubs(:"<=>").with(@long_acl).returns(0)
+        allow(@long_acl).to receive(:"<=>").with(@short_acl).and_return(0)
+        allow(@short_acl).to receive(:"<=>").with(@long_acl).and_return(0)
       end
 
       it "should select the first match" do
         @right.newright("/path/to", 0)
         @right.newright("/path/to/there", 0)
 
-        @long_acl.stubs(:match?).returns(true)
-        @short_acl.stubs(:match?).returns(true)
+        allow(@long_acl).to receive(:match?).and_return(true)
+        allow(@short_acl).to receive(:match?).and_return(true)
 
-        @short_acl.expects(:allowed?).returns(true)
-        @long_acl.expects(:allowed?).never
+        expect(@short_acl).to receive(:allowed?).and_return(true)
+        expect(@long_acl).not_to receive(:allowed?)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -178,11 +177,11 @@ describe Puppet::Network::Rights do
         @right.newright("/path/to/there", 0, nil)
         @right.newright("/path/to", 0, nil)
 
-        @long_acl.stubs(:match?).returns(true)
-        @short_acl.stubs(:match?).returns(true)
+        allow(@long_acl).to receive(:match?).and_return(true)
+        allow(@short_acl).to receive(:match?).and_return(true)
 
-        @long_acl.expects(:allowed?).returns(:dunno)
-        @short_acl.expects(:allowed?).returns(true)
+        expect(@long_acl).to receive(:allowed?).and_return(:dunno)
+        expect(@short_acl).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -191,11 +190,11 @@ describe Puppet::Network::Rights do
         @right.newright("/path/to/there", 0)
         @right.newright("/path/to", 0)
 
-        @long_acl.stubs(:match?).returns(false)
-        @short_acl.stubs(:match?).returns(true)
+        allow(@long_acl).to receive(:match?).and_return(false)
+        allow(@short_acl).to receive(:match?).and_return(true)
 
-        @long_acl.expects(:allowed?).never
-        @short_acl.expects(:allowed?).returns(true)
+        expect(@long_acl).not_to receive(:allowed?)
+        expect(@short_acl).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -203,8 +202,8 @@ describe Puppet::Network::Rights do
       it "should not raise an AuthorizationError if allowed" do
         @right.newright("/path/to/there", 0)
 
-        @long_acl.stubs(:match?).returns(true)
-        @long_acl.stubs(:allowed?).returns(true)
+        allow(@long_acl).to receive(:match?).and_return(true)
+        allow(@long_acl).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/path/to/there/and/there", {})).to eq(nil)
       end
@@ -212,8 +211,8 @@ describe Puppet::Network::Rights do
       it "should raise an AuthorizationError if the match is denied" do
         @right.newright("/path/to/there", 0, nil)
 
-        @long_acl.stubs(:match?).returns(true)
-        @long_acl.stubs(:allowed?).returns(false)
+        allow(@long_acl).to receive(:match?).and_return(true)
+        allow(@long_acl).to receive(:allowed?).and_return(false)
 
         expect(@right.is_forbidden_and_why?("/path/to/there", {})).to be_instance_of(Puppet::Network::AuthorizationError)
       end
@@ -225,25 +224,25 @@ describe Puppet::Network::Rights do
 
     describe "with regex acls" do
       before :each do
-        @regex_acl1 = stub 'regex_acl1', :name => "/files/(.*)/myfile", :line => 0, :file => 'dummy'
-        Puppet::Network::Rights::Right.stubs(:new).with("~ /files/(.*)/myfile", 0, nil).returns(@regex_acl1)
+        @regex_acl1 = double('regex_acl1', :name => "/files/(.*)/myfile", :line => 0, :file => 'dummy')
+        allow(Puppet::Network::Rights::Right).to receive(:new).with("~ /files/(.*)/myfile", 0, nil).and_return(@regex_acl1)
 
-        @regex_acl2 = stub 'regex_acl2', :name => "/files/(.*)/myfile/", :line => 0, :file => 'dummy'
-        Puppet::Network::Rights::Right.stubs(:new).with("~ /files/(.*)/myfile/", 0, nil).returns(@regex_acl2)
+        @regex_acl2 = double('regex_acl2', :name => "/files/(.*)/myfile/", :line => 0, :file => 'dummy')
+        allow(Puppet::Network::Rights::Right).to receive(:new).with("~ /files/(.*)/myfile/", 0, nil).and_return(@regex_acl2)
 
-        @regex_acl1.stubs(:"<=>").with(@regex_acl2).returns(0)
-        @regex_acl2.stubs(:"<=>").with(@regex_acl1).returns(0)
+        allow(@regex_acl1).to receive(:"<=>").with(@regex_acl2).and_return(0)
+        allow(@regex_acl2).to receive(:"<=>").with(@regex_acl1).and_return(0)
       end
 
       it "should select the first match" do
         @right.newright("~ /files/(.*)/myfile", 0)
         @right.newright("~ /files/(.*)/myfile/", 0)
 
-        @regex_acl1.stubs(:match?).returns(true)
-        @regex_acl2.stubs(:match?).returns(true)
+        allow(@regex_acl1).to receive(:match?).and_return(true)
+        allow(@regex_acl2).to receive(:match?).and_return(true)
 
-        @regex_acl1.expects(:allowed?).returns(true)
-        @regex_acl2.expects(:allowed?).never
+        expect(@regex_acl1).to receive(:allowed?).and_return(true)
+        expect(@regex_acl2).not_to receive(:allowed?)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -252,11 +251,11 @@ describe Puppet::Network::Rights do
         @right.newright("~ /files/(.*)/myfile", 0)
         @right.newright("~ /files/(.*)/myfile/", 0)
 
-        @regex_acl1.stubs(:match?).returns(true)
-        @regex_acl2.stubs(:match?).returns(true)
+        allow(@regex_acl1).to receive(:match?).and_return(true)
+        allow(@regex_acl2).to receive(:match?).and_return(true)
 
-        @regex_acl1.expects(:allowed?).returns(:dunno)
-        @regex_acl2.expects(:allowed?).returns(true)
+        expect(@regex_acl1).to receive(:allowed?).and_return(:dunno)
+        expect(@regex_acl2).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -265,11 +264,11 @@ describe Puppet::Network::Rights do
         @right.newright("~ /files/(.*)/myfile", 0)
         @right.newright("~ /files/(.*)/myfile/", 0)
 
-        @regex_acl1.stubs(:match?).returns(false)
-        @regex_acl2.stubs(:match?).returns(true)
+        allow(@regex_acl1).to receive(:match?).and_return(false)
+        allow(@regex_acl2).to receive(:match?).and_return(true)
 
-        @regex_acl1.expects(:allowed?).never
-        @regex_acl2.expects(:allowed?).returns(true)
+        expect(@regex_acl1).not_to receive(:allowed?)
+        expect(@regex_acl2).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -277,8 +276,8 @@ describe Puppet::Network::Rights do
       it "should not raise an AuthorizationError if allowed" do
         @right.newright("~ /files/(.*)/myfile", 0)
 
-        @regex_acl1.stubs(:match?).returns(true)
-        @regex_acl1.stubs(:allowed?).returns(true)
+        allow(@regex_acl1).to receive(:match?).and_return(true)
+        allow(@regex_acl1).to receive(:allowed?).and_return(true)
 
         expect(@right.is_forbidden_and_why?("/files/repository/myfile/other", {})).to eq(nil)
       end
@@ -425,13 +424,13 @@ describe Puppet::Network::Rights do
       end
 
       it "should interpolate allow/deny patterns with the given match" do
-        @acl.expects(:interpolate).with(:match)
+        expect(@acl).to receive(:interpolate).with(:match)
 
         @acl.allowed?("me","127.0.0.1", { :method => :save, :match => :match, :authenticated => true })
       end
 
       it "should reset interpolation after the match" do
-        @acl.expects(:reset_interpolation)
+        expect(@acl).to receive(:reset_interpolation)
 
         @acl.allowed?("me","127.0.0.1", { :method => :save, :match => :match, :authenticated => true })
       end

data/spec/unit/node/environment_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'tmpdir'
@@ -112,7 +111,7 @@ describe Puppet::Node::Environment do
 
     describe "when managing known resource types" do
       before do
-        env.stubs(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
+        allow(env).to receive(:perform_initial_import).and_return(Puppet::Parser::AST::Hostclass.new(''))
       end
 
       it "creates a resource type collection if none exists" do
@@ -124,13 +123,13 @@ describe Puppet::Node::Environment do
       end
 
       it "performs the initial import when creating a new collection" do
-        env.expects(:perform_initial_import).returns(Puppet::Parser::AST::Hostclass.new(''))
+        expect(env).to receive(:perform_initial_import).and_return(Puppet::Parser::AST::Hostclass.new(''))
         env.known_resource_types
       end
 
       it "generates a new TypeCollection if the current one requires reparsing" do
         old_type_collection = env.known_resource_types
-        old_type_collection.stubs(:parse_failed?).returns true
+        allow(old_type_collection).to receive(:parse_failed?).and_return(true)
 
         env.check_for_reparse
 
@@ -171,7 +170,7 @@ describe Puppet::Node::Environment do
       end
 
       context "when disable_per_environment_manifest is true" do
-        let(:config) { mock('config') }
+        let(:config) { double('config') }
         let(:global_modulepath) { ["/global/modulepath"] }
         let(:envconf) { Puppet::Settings::EnvironmentConf.new("/some/direnv", config, global_modulepath) }
 
@@ -180,12 +179,12 @@ describe Puppet::Node::Environment do
         end
 
         def assert_manifest_conflict(expectation, envconf_manifest_value)
-          config.expects(:setting).with(:manifest).returns(
-            mock('setting', :value => envconf_manifest_value)
+          expect(config).to receive(:setting).with(:manifest).and_return(
+            double('setting', :value => envconf_manifest_value)
           )
           environment = Puppet::Node::Environment.create(:directory, [], '/default/manifests/site.pp')
           loader = Puppet::Environments::Static.new(environment)
-          loader.stubs(:get_conf).returns(envconf)
+          allow(loader).to receive(:get_conf).and_return(envconf)
 
           Puppet.override(:environments => loader) do
             if expectation
@@ -404,7 +403,7 @@ describe Puppet::Node::Environment do
           it "creates modules with the correct environment" do
             PuppetSpec::Modules.generate_files('foo', first_modulepath)
 
-            env.modules.each do |mod| 
+            env.modules.each do |mod|
               expect(mod.environment).to eq(env)
             end
           end
@@ -419,7 +418,7 @@ describe Puppet::Node::Environment do
               }
             )
 
-            Puppet.expects(:log_exception).with(is_a(Puppet::Module::MissingMetadata))
+            expect(Puppet).to receive(:log_exception).with(be_a(Puppet::Module::MissingMetadata))
 
             env.modules
           end
@@ -431,7 +430,7 @@ describe Puppet::Node::Environment do
       let(:loaders) { Puppet::Pops::Loaders.new(env) }
 
       before(:each) do
-        Puppet::Parser::Compiler.any_instance.stubs(:loaders).returns(loaders)
+        allow_any_instance_of(Puppet::Parser::Compiler).to receive(:loaders).and_return(loaders)
         Puppet.push_context({:loaders => loaders, :current_environment => env})
       end
 
@@ -495,9 +494,9 @@ describe Puppet::Node::Environment do
 
   describe "managing module translations" do
     it "creates a new text domain the first time we try to use the text domain" do
-      Puppet::GettextConfig.expects(:reset_text_domain).with(env.name)
-      Puppet::ModuleTranslations.expects(:load_from_modulepath)
-      Puppet::GettextConfig.expects(:clear_text_domain)
+      expect(Puppet::GettextConfig).to receive(:reset_text_domain).with(env.name)
+      expect(Puppet::ModuleTranslations).to receive(:load_from_modulepath)
+      expect(Puppet::GettextConfig).to receive(:clear_text_domain)
 
       env.with_text_domain do; end
     end
@@ -505,7 +504,7 @@ describe Puppet::Node::Environment do
     it "uses the existing text domain once it has been created" do
       env.with_text_domain do; end
 
-      Puppet::GettextConfig.expects(:use_text_domain).with(env.name)
+      expect(Puppet::GettextConfig).to receive(:use_text_domain).with(env.name)
       env.with_text_domain do; end
     end
 

data/spec/unit/node/facts_spec.rb

@@ -1,5 +1,3 @@
-#! /usr/bin/env ruby
-
 require 'spec_helper'
 require 'puppet/node/facts'
 require 'matchers/json'
@@ -97,14 +95,14 @@ describe Puppet::Node::Facts, "when indirecting" do
 
   describe "when indirecting" do
     before do
-      @indirection = stub 'indirection', :request => mock('request'), :name => :facts
+      @indirection = double('indirection', :request => double('request'), :name => :facts)
 
       @facts = Puppet::Node::Facts.new("me", "one" => "two")
     end
 
     it "should redirect to the specified fact store for storage" do
-      Puppet::Node::Facts.stubs(:indirection).returns(@indirection)
-      @indirection.expects(:save)
+      allow(Puppet::Node::Facts).to receive(:indirection).and_return(@indirection)
+      expect(@indirection).to receive(:save)
       Puppet::Node::Facts.indirection.save(@facts)
     end
 
@@ -190,7 +188,7 @@ describe Puppet::Node::Facts, "when indirecting" do
       end
 
       it "should generate properly formatted json" do
-        Time.stubs(:now).returns(@timestamp)
+        allow(Time).to receive(:now).and_return(@timestamp)
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
         result = JSON.parse(facts.to_json)
@@ -201,7 +199,7 @@ describe Puppet::Node::Facts, "when indirecting" do
       end
 
       it "should generate valid facts data against the facts schema" do
-        Time.stubs(:now).returns(@timestamp)
+        allow(Time).to receive(:now).and_return(@timestamp)
         facts = Puppet::Node::Facts.new("foo", {'a' => 1, 'b' => 2, 'c' => 3})
         facts.expiration = @expiration
 

data/spec/unit/node_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet_spec/files'
@@ -11,7 +10,6 @@ describe Puppet::Node do
   let(:env_loader) { Puppet::Environments::Static.new(environment) }
 
   describe "when managing its environment" do
-
     it "provides an environment instance" do
       expect(Puppet::Node.new("foo", :environment => environment).environment.name).to eq(:bar)
     end
@@ -135,7 +133,6 @@ describe Puppet::Node do
     it "errors if name is nil" do
       expect { Puppet::Node.from_data_hash({ })}.to raise_error(ArgumentError, /No name provided in serialized data/)
     end
-
   end
 
   describe "when converting to json" do
@@ -274,18 +271,18 @@ describe Puppet::Node, "when merging facts" do
     let(:facts) { Puppet::Node::Facts.new(@node.name, "foo" => "bar") }
 
     it "accepts facts to merge with the node" do
-      @node.expects(:merge).with({ 'foo' => 'bar' })
+      expect(@node).to receive(:merge).with({ 'foo' => 'bar' })
       @node.fact_merge(facts)
     end
 
     it "will not query the facts indirection if facts are supplied" do
-      Puppet::Node::Facts.indirection.expects(:find).never
+      expect(Puppet::Node::Facts.indirection).not_to receive(:find)
       @node.fact_merge(facts)
     end
   end
 
   it "recovers with a Puppet::Error if something is thrown from the facts indirection" do
-    Puppet::Node::Facts.indirection.expects(:find).raises "something bad happened in the indirector"
+    expect(Puppet::Node::Facts.indirection).to receive(:find).and_raise("something bad happened in the indirector")
     expect { @node.fact_merge }.to raise_error(Puppet::Error, /Could not retrieve facts for testnode: something bad happened in the indirector/)
   end
 
@@ -303,7 +300,7 @@ describe Puppet::Node, "when merging facts" do
 
   it "warns when a parameter value is not updated" do
     @node = Puppet::Node.new("testnode", :parameters => {"one" => "a"})
-    Puppet.expects(:warning).with('The node parameter \'one\' for node \'testnode\' was already set to \'a\'. It could not be set to \'b\'')
+    expect(Puppet).to receive(:warning).with('The node parameter \'one\' for node \'testnode\' was already set to \'a\'. It could not be set to \'b\'')
     @node.merge "one" => "b"
   end
 
@@ -377,9 +374,7 @@ describe Puppet::Node, "when merging facts" do
     end
 
     context "when a node is initialized from new" do
-
       context "when a node is initialzed with an environment" do
-
         it "adds the environment to the list of parameters" do
           Puppet[:environment] = "one"
           @node = Puppet::Node.new("testnode", :environment => "one")
@@ -401,7 +396,6 @@ describe Puppet::Node, "when merging facts" do
       end
 
       context "when a node is initialized without an environment" do
-
         it "it perfers an environment name to an environment fact" do
           @node = Puppet::Node.new("testnode")
           @node.environment_name = "one"

data/spec/unit/other/selinux_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 describe Puppet::Type.type(:file), " when manipulating file contexts" do

data/spec/unit/parameter/boolean_spec.rb

@@ -1,10 +1,9 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet'
 require 'puppet/parameter/boolean'
 
 describe Puppet::Parameter::Boolean do
-  let (:resource) { mock('resource') }
+  let (:resource) { double('resource') }
   describe "after initvars" do
     before { described_class.initvars }
     it "should have the correct value_collection" do