puppet 5.5.12-x64-mingw32 → 5.5.13-x64-mingw32

data/spec/unit/indirector/node/msgpack_spec.rb

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

data/spec/unit/indirector/node/plain_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/node/plain'
@@ -14,7 +13,7 @@ describe Puppet::Node::Plain do
   let(:node_indirection) { Puppet::Node::Plain.new }
 
   it "should merge facts from the request if supplied" do
-    Puppet::Node::Facts.indirection.expects(:find).never
+    expect(Puppet::Node::Facts.indirection).not_to receive(:find)
     request.options[:facts] = request_facts
     node = node_indirection.find(request)
     expect(node.parameters).to include(request_fact_values)
@@ -22,7 +21,7 @@ describe Puppet::Node::Plain do
   end
 
   it "should find facts if none are supplied" do
-    Puppet::Node::Facts.indirection.expects(:find).with(nodename, :environment => environment).returns(indirection_facts)
+    expect(Puppet::Node::Facts.indirection).to receive(:find).with(nodename, :environment => environment).and_return(indirection_facts)
     request.options.delete(:facts)
     node = node_indirection.find(request)
     expect(node.parameters).to include(indirection_fact_values)
@@ -32,5 +31,4 @@ describe Puppet::Node::Plain do
   it "should set the node environment from the request" do
     expect(node_indirection.find(request).environment).to eq(environment)
   end
-
 end

data/spec/unit/indirector/node/rest_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/node/rest'

data/spec/unit/indirector/node/store_configs_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/node'
 require 'puppet/indirector/memory'

data/spec/unit/indirector/node/write_only_yaml_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/node'
@@ -6,7 +5,7 @@ require 'puppet/indirector/node/write_only_yaml'
 
 describe Puppet::Node::WriteOnlyYaml do
   it "should be deprecated" do
-    Puppet.expects(:warn_once).with('deprecations', 'Puppet::Node::WriteOnlyYaml', 'Puppet::Node::WriteOnlyYaml is deprecated and will be removed in a future release of Puppet.')
+    expect(Puppet).to receive(:warn_once).with('deprecations', 'Puppet::Node::WriteOnlyYaml', 'Puppet::Node::WriteOnlyYaml is deprecated and will be removed in a future release of Puppet.')
     described_class.new
   end
 end

data/spec/unit/indirector/node/yaml_spec.rb

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

data/spec/unit/indirector/none_spec.rb

@@ -3,8 +3,8 @@ require 'puppet/indirector/none'
 
 describe Puppet::Indirector::None do
   before do
-    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-    Puppet::Indirector::Indirection.stubs(:instance).returns(indirection)
+    allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
+    allow(Puppet::Indirector::Indirection).to receive(:instance).and_return(indirection)
 
     module Testing; end
     @none_class = class Testing::None < Puppet::Indirector::None
@@ -14,10 +14,10 @@ describe Puppet::Indirector::None do
     @data_binder = @none_class.new
   end
 
-  let(:model)   { mock('model') }
-  let(:request) { stub('request', :key => "port") }
+  let(:model)   { double('model') }
+  let(:request) { double('request', :key => "port") }
   let(:indirection) do
-    stub('indirection', :name => :none, :register_terminus_type => nil,
+    double('indirection', :name => :none, :register_terminus_type => nil,
       :model => model)
   end
 

data/spec/unit/indirector/plain_spec.rb

@@ -1,13 +1,12 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector/plain'
 
 describe Puppet::Indirector::Plain do
   before do
-    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
-    @model = mock 'model'
-    @indirection = stub 'indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model
-    Puppet::Indirector::Indirection.stubs(:instance).returns(@indirection)
+    allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
+    @model = double('model')
+    @indirection = double('indirection', :name => :mystuff, :register_terminus_type => nil, :model => @model)
+    allow(Puppet::Indirector::Indirection).to receive(:instance).and_return(@indirection)
 
     module Testing; end
     @plain_class = class Testing::MyPlain < Puppet::Indirector::Plain
@@ -16,12 +15,12 @@ describe Puppet::Indirector::Plain do
 
     @searcher = @plain_class.new
 
-    @request = stub 'request', :key => "yay"
+    @request = double('request', :key => "yay")
   end
 
   it "should return return an instance of the indirected model" do
-    object = mock 'object'
-    @model.expects(:new).with(@request.key).returns object
+    object = double('object')
+    expect(@model).to receive(:new).with(@request.key).and_return(object)
     expect(@searcher.find(@request)).to equal(object)
   end
 end

data/spec/unit/indirector/report/msgpack_spec.rb

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

data/spec/unit/indirector/report/processor_spec.rb

@@ -1,11 +1,10 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/report/processor'
 
 describe Puppet::Transaction::Report::Processor do
   before do
-    Puppet.settings.stubs(:use).returns(true)
+    allow(Puppet.settings).to receive(:use).and_return(true)
   end
 
   it "should provide a method for saving reports" do
@@ -20,13 +19,13 @@ end
 
 describe Puppet::Transaction::Report::Processor, " when processing a report" do
   before do
-    Puppet.settings.stubs(:use)
+    allow(Puppet.settings).to receive(:use)
     @reporter = Puppet::Transaction::Report::Processor.new
-    @request = stub 'request', :instance => stub("report", :host => 'hostname'), :key => 'node'
+    @request = double('request', :instance => double("report", :host => 'hostname'), :key => 'node')
   end
 
   it "should not save the report if reports are set to 'none'" do
-    Puppet::Reports.expects(:report).never
+    expect(Puppet::Reports).not_to receive(:report)
     Puppet[:reports] = 'none'
 
     request = Puppet::Indirector::Request.new(:indirection_name, :head, "key", nil)
@@ -40,19 +39,19 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
     Puppet[:reports] = "one,two"
     expect(@reporter.send(:reports)).to eq(%w{one two})
 
-    Puppet::Reports.expects(:report).with('one')
-    Puppet::Reports.expects(:report).with('two')
+    expect(Puppet::Reports).to receive(:report).with('one')
+    expect(Puppet::Reports).to receive(:report).with('two')
 
     @reporter.save(@request)
   end
 
   it "should destroy reports for each processor that responds to destroy" do
     Puppet[:reports] = "http,store"
-    http_report = mock()
-    store_report = mock()
-    store_report.expects(:destroy).with(@request.key)
-    Puppet::Reports.expects(:report).with('http').returns(http_report)
-    Puppet::Reports.expects(:report).with('store').returns(store_report)
+    http_report = double()
+    store_report = double()
+    expect(store_report).to receive(:destroy).with(@request.key)
+    expect(Puppet::Reports).to receive(:report).with('http').and_return(http_report)
+    expect(Puppet::Reports).to receive(:report).with('store').and_return(store_report)
     @reporter.destroy(@request)
   end
 end
@@ -60,20 +59,20 @@ end
 describe Puppet::Transaction::Report::Processor, " when processing a report" do
   before do
     Puppet[:reports] = "one"
-    Puppet.settings.stubs(:use)
+    allow(Puppet.settings).to receive(:use)
     @reporter = Puppet::Transaction::Report::Processor.new
 
-    @report_type = mock 'one'
-    @dup_report = mock 'dupe report'
-    @dup_report.stubs(:process)
+    @report_type = double('one')
+    @dup_report = double('dupe report')
+    allow(@dup_report).to receive(:process)
     @report = Puppet::Transaction::Report.new
-    @report.expects(:dup).returns(@dup_report)
+    expect(@report).to receive(:dup).and_return(@dup_report)
 
-    @request = stub 'request', :instance => @report
+    @request = double('request', :instance => @report)
 
-    Puppet::Reports.expects(:report).with("one").returns(@report_type)
+    expect(Puppet::Reports).to receive(:report).with("one").and_return(@report_type)
 
-    @dup_report.expects(:extend).with(@report_type)
+    expect(@dup_report).to receive(:extend).with(@report_type)
   end
 
   # LAK:NOTE This is stupid, because the code is so short it doesn't
@@ -88,13 +87,13 @@ describe Puppet::Transaction::Report::Processor, " when processing a report" do
   end
 
   it "should call the report type's :process method" do
-    @dup_report.expects(:process)
+    expect(@dup_report).to receive(:process)
     @reporter.save(@request)
   end
 
   it "should not raise exceptions" do
     Puppet[:trace] = false
-    @dup_report.expects(:process).raises(ArgumentError)
+    expect(@dup_report).to receive(:process).and_raise(ArgumentError)
     expect { @reporter.save(@request) }.not_to raise_error
   end
 end

data/spec/unit/indirector/report/rest_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/report/rest'
@@ -33,10 +32,10 @@ describe Puppet::Transaction::Report::Rest do
   end
 
   def mock_response(code, body, content_type='text/plain', encoding=nil)
-    obj = stub('http 200 ok', :code => code.to_s, :body => body)
-    obj.stubs(:[]).with('content-type').returns(content_type)
-    obj.stubs(:[]).with('content-encoding').returns(encoding)
-    obj.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(Puppet.version)
+    obj = double('http 200 ok', :code => code.to_s, :body => body)
+    allow(obj).to receive(:[]).with('content-type').and_return(content_type)
+    allow(obj).to receive(:[]).with('content-encoding').and_return(encoding)
+    allow(obj).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(Puppet.version)
     obj
   end
 
@@ -46,18 +45,18 @@ describe Puppet::Transaction::Report::Rest do
 
   describe "#save" do
     let(:response) { mock_response(200, 'body') }
-    let(:connection) { stub('mock http connection', :put => response, :verify_callback= => nil) }
+    let(:connection) { double('mock http connection', :put => response, :verify_callback= => nil) }
     let(:instance) { model.new('the thing', 'some contents') }
     let(:request) { save_request(instance.name, instance) }
     let(:body) { ["store", "http"].to_pson }
 
     before :each do
-      terminus.stubs(:network).returns(connection)
+      allow(terminus).to receive(:network).and_return(connection)
     end
 
     it "deserializes the response as an array of report processor names" do
       response = mock_response('200', body, 'text/pson')
-      connection.expects(:put).returns response
+      expect(connection).to receive(:put).and_return(response)
 
       expect(terminus.save(request)).to eq(["store", "http"])
     end
@@ -68,8 +67,8 @@ describe Puppet::Transaction::Report::Rest do
           Puppet[:preferred_serialization_format] = "json"
 
           response = mock_response('500', '{}', 'text/pson')
-          response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
-          connection.expects(:put).returns response
+          allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("4.10.1")
+          expect(connection).to receive(:put).and_return(response)
 
           expect {
             terminus.save(request)
@@ -80,8 +79,8 @@ describe Puppet::Transaction::Report::Rest do
           Puppet[:preferred_serialization_format] = "pson"
 
           response = mock_response('500', '{}', 'text/pson')
-          response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns("4.10.1")
-          connection.expects(:put).returns response
+          allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return("4.10.1")
+          expect(connection).to receive(:put).and_return(response)
 
           expect {
             terminus.save(request)

data/spec/unit/indirector/report/yaml_spec.rb

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

data/spec/unit/indirector/request_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'matchers/json'
 require 'puppet/indirector/request'
@@ -20,7 +19,7 @@ describe Puppet::Indirector::Request do
     end
 
     it "should use the name of the provided instance as its key if an instance is provided as the key instead of a string" do
-      instance = mock 'instance', :name => "mykey"
+      instance = double('instance', :name => "mykey")
       request = Puppet::Indirector::Request.new(:ind, :method, nil, instance)
       expect(request.key).to eq("mykey")
       expect(request.instance).to equal(instance)
@@ -195,25 +194,25 @@ describe Puppet::Indirector::Request do
   end
 
   it "should look use the Indirection class to return the appropriate indirection" do
-    ind = mock 'indirection'
-    Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
+    ind = double('indirection')
+    expect(Puppet::Indirector::Indirection).to receive(:instance).with(:myind).and_return(ind)
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     expect(request.indirection).to equal(ind)
   end
 
   it "should use its indirection to look up the appropriate model" do
-    ind = mock 'indirection'
-    Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns ind
+    ind = double('indirection')
+    expect(Puppet::Indirector::Indirection).to receive(:instance).with(:myind).and_return(ind)
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
-    ind.expects(:model).returns "mymodel"
+    expect(ind).to receive(:model).and_return("mymodel")
 
     expect(request.model).to eq("mymodel")
   end
 
   it "should fail intelligently when asked to find a model but the indirection cannot be found" do
-    Puppet::Indirector::Indirection.expects(:instance).with(:myind).returns nil
+    expect(Puppet::Indirector::Indirection).to receive(:instance).with(:myind).and_return(nil)
     request = Puppet::Indirector::Request.new(:myind, :method, :key, nil)
 
     expect { request.model }.to raise_error(ArgumentError)
@@ -442,16 +441,16 @@ describe Puppet::Indirector::Request do
 
       context "when SRV returns servers" do
         before :each do
-          @dns_mock = mock('dns')
-          Resolv::DNS.expects(:new).returns(@dns_mock)
+          @dns_mock = double('dns')
+          expect(Resolv::DNS).to receive(:new).and_return(@dns_mock)
 
           @port = 7205
           @host = '_x-puppet._tcp.example.com'
           @srv_records = [Resolv::DNS::Resource::IN::SRV.new(0, 0, @port, @host)]
 
-          @dns_mock.expects(:getresources).
+          expect(@dns_mock).to receive(:getresources).
             with("_x-puppet._tcp.#{Puppet.settings[:srv_domain]}", Resolv::DNS::Resource::IN::SRV).
-            returns(@srv_records)
+            and_return(@srv_records)
         end
 
         it "yields a request using the server and port from the SRV record" do

data/spec/unit/indirector/resource/ral_spec.rb

@@ -1,42 +1,39 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
+require 'puppet/type/user'
 
 describe "Puppet::Resource::Ral" do
-
   it "disallows remote requests" do
     expect(Puppet::Resource::Ral.new.allow_remote_requests?).to eq(false)
   end
 
   describe "find" do
     before do
-      @request = stub 'request', :key => "user/root"
+      @request = double('request', :key => "user/root")
     end
 
     it "should find an existing instance" do
-      my_resource    = stub "my user resource"
+      my_resource    = double("my user resource")
 
-      wrong_instance = stub "wrong user", :name => "bob"
-      my_instance    = stub "my user",    :name => "root", :to_resource => my_resource
+      wrong_instance = double("wrong user", :name => "bob")
+      my_instance    = double("my user",    :name => "root", :to_resource => my_resource)
 
-      require 'puppet/type/user'
-      Puppet::Type::User.expects(:instances).returns([ wrong_instance, my_instance, wrong_instance ])
+      expect(Puppet::Type::User).to receive(:instances).and_return([ wrong_instance, my_instance, wrong_instance ])
       expect(Puppet::Resource::Ral.new.find(@request)).to eq(my_resource)
     end
 
     it "should produce Puppet::Error instead of ArgumentError" do
-      @bad_request = stub 'thiswillcauseanerror', :key => "thiswill/causeanerror"
+      @bad_request = double('thiswillcauseanerror', :key => "thiswill/causeanerror")
       expect{Puppet::Resource::Ral.new.find(@bad_request)}.to raise_error(Puppet::Error)
     end
 
     it "if there is no instance, it should create one" do
-      wrong_instance = stub "wrong user", :name => "bob"
-      root = mock "Root User"
-      root_resource = mock "Root Resource"
+      wrong_instance = double("wrong user", :name => "bob")
+      root = double("Root User")
+      root_resource = double("Root Resource")
 
-      require 'puppet/type/user'
-      Puppet::Type::User.expects(:instances).returns([ wrong_instance, wrong_instance ])
-      Puppet::Type::User.expects(:new).with(has_entry(:name => "root")).returns(root)
-      root.expects(:to_resource).returns(root_resource)
+      expect(Puppet::Type::User).to receive(:instances).and_return([ wrong_instance, wrong_instance ])
+      expect(Puppet::Type::User).to receive(:new).with(hash_including(name: "root")).and_return(root)
+      expect(root).to receive(:to_resource).and_return(root_resource)
 
       result = Puppet::Resource::Ral.new.find(@request)
 
@@ -46,72 +43,68 @@ describe "Puppet::Resource::Ral" do
 
   describe "search" do
     before do
-      @request = stub 'request', :key => "user/", :options => {}
+      @request = double('request', :key => "user/", :options => {})
     end
 
     it "should convert ral resources into regular resources" do
-      my_resource = stub "my user resource"
-      my_instance = stub "my user", :name => "root", :to_resource => my_resource
+      my_resource = double("my user resource")
+      my_instance = double("my user", :name => "root", :to_resource => my_resource)
 
-      require 'puppet/type/user'
-      Puppet::Type::User.expects(:instances).returns([ my_instance ])
+      expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
     it "should filter results by name if there's a name in the key" do
-      my_resource    = stub "my user resource"
-      my_resource.stubs(:to_resource).returns(my_resource)
-      my_resource.stubs(:[]).with(:name).returns("root")
+      my_resource = double("my user resource")
+      allow(my_resource).to receive(:to_resource).and_return(my_resource)
+      allow(my_resource).to receive(:[]).with(:name).and_return("root")
 
-      wrong_resource = stub "wrong resource"
-      wrong_resource.stubs(:to_resource).returns(wrong_resource)
-      wrong_resource.stubs(:[]).with(:name).returns("bad")
+      wrong_resource = double("wrong resource")
+      allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
+      allow(wrong_resource).to receive(:[]).with(:name).and_return("bad")
 
-      my_instance    = stub "my user",    :to_resource => my_resource
-      wrong_instance = stub "wrong user", :to_resource => wrong_resource
+      my_instance    = double("my user",    :to_resource => my_resource)
+      wrong_instance = double("wrong user", :to_resource => wrong_resource)
 
-      @request = stub 'request', :key => "user/root", :options => {}
+      @request = double('request', :key => "user/root", :options => {})
 
-      require 'puppet/type/user'
-      Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
+      expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance, wrong_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
     it "should filter results by query parameters" do
-      wrong_resource = stub "my user resource"
-      wrong_resource.stubs(:to_resource).returns(wrong_resource)
-      wrong_resource.stubs(:[]).with(:name).returns("root")
+      wrong_resource = double("my user resource")
+      allow(wrong_resource).to receive(:to_resource).and_return(wrong_resource)
+      allow(wrong_resource).to receive(:[]).with(:name).and_return("root")
 
-      my_resource = stub "wrong resource"
-      my_resource.stubs(:to_resource).returns(my_resource)
-      my_resource.stubs(:[]).with(:name).returns("bob")
+      my_resource = double("wrong resource")
+      allow(my_resource).to receive(:to_resource).and_return(my_resource)
+      allow(my_resource).to receive(:[]).with(:name).and_return("bob")
 
-      my_instance    = stub "my user",    :to_resource => my_resource
-      wrong_instance = stub "wrong user", :to_resource => wrong_resource
+      my_instance    = double("my user",    :to_resource => my_resource)
+      wrong_instance = double("wrong user", :to_resource => wrong_resource)
 
-      @request = stub 'request', :key => "user/", :options => {:name => "bob"}
+      @request = double('request', :key => "user/", :options => {:name => "bob"})
 
-      require 'puppet/type/user'
-      Puppet::Type::User.expects(:instances).returns([ my_instance, wrong_instance ])
+      expect(Puppet::Type::User).to receive(:instances).and_return([ my_instance, wrong_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([my_resource])
     end
 
     it "should return sorted results" do
-      a_resource = stub "alice resource"
-      a_resource.stubs(:to_resource).returns(a_resource)
-      a_resource.stubs(:title).returns("alice")
+      a_resource = double("alice resource")
+      allow(a_resource).to receive(:to_resource).and_return(a_resource)
+      allow(a_resource).to receive(:title).and_return("alice")
 
-      b_resource = stub "bob resource"
-      b_resource.stubs(:to_resource).returns(b_resource)
-      b_resource.stubs(:title).returns("bob")
+      b_resource = double("bob resource")
+      allow(b_resource).to receive(:to_resource).and_return(b_resource)
+      allow(b_resource).to receive(:title).and_return("bob")
 
-      a_instance = stub "alice user", :to_resource => a_resource
-      b_instance = stub "bob user",   :to_resource => b_resource
+      a_instance = double("alice user", :to_resource => a_resource)
+      b_instance = double("bob user",   :to_resource => b_resource)
 
-      @request = stub 'request', :key => "user/", :options => {}
+      @request = double('request', :key => "user/", :options => {})
 
-      require 'puppet/type/user'
-      Puppet::Type::User.expects(:instances).returns([ b_instance, a_instance ])
+      expect(Puppet::Type::User).to receive(:instances).and_return([ b_instance, a_instance ])
       expect(Puppet::Resource::Ral.new.search(@request)).to eq([a_resource, b_resource])
     end
   end