puppet 5.5.12-universal-darwin → 5.5.13-universal-darwin

data/spec/unit/indirector/face_spec.rb

@@ -1,14 +1,13 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector/face'
 
 describe Puppet::Indirector::Face do
   subject do
     instance = Puppet::Indirector::Face.new(:test, '0.0.1')
-    indirection = stub('indirection',
+    indirection = double('indirection',
                        :name => :stub_indirection,
                        :reset_terminus_class => nil)
-    instance.stubs(:indirection).returns indirection
+    allow(instance).to receive(:indirection).and_return(indirection)
     instance
   end
 
@@ -19,7 +18,7 @@ describe Puppet::Indirector::Face do
   end
 
   it "should return the sorted to_s list of terminus classes" do
-    Puppet::Indirector::Terminus.expects(:terminus_classes).returns([
+    expect(Puppet::Indirector::Terminus).to receive(:terminus_classes).and_return([
       :yaml,
       :compiler,
       :rest
@@ -34,7 +33,7 @@ describe Puppet::Indirector::Face do
   describe "as an instance" do
     it "should be able to determine its indirection" do
       # Loading actions here can get, um, complicated
-      Puppet::Face.stubs(:load_actions)
+      allow(Puppet::Face).to receive(:load_actions)
       expect(Puppet::Indirector::Face.new(:catalog, '0.0.1').indirection).to equal(Puppet::Resource::Catalog.indirection)
     end
   end
@@ -53,17 +52,18 @@ describe Puppet::Indirector::Face do
     end
 
     it "should call the indirection method with options when the '#{method}' action is invoked" do
-      subject.indirection.expects(method).with(:test, *params(method, {}))
+      expect(subject.indirection).to receive(method).with(:test, *params(method, {}))
       subject.send(method, :test)
     end
+
     it "should forward passed options" do
-      subject.indirection.expects(method).with(:test, *params(method, {'one'=>'1'}))
+      expect(subject.indirection).to receive(method).with(:test, *params(method, {'one'=>'1'}))
       subject.send(method, :test, :extra => {'one'=>'1'})
     end
   end
 
   it "should default key to certname for find action" do
-    subject.indirection.expects(:find).with(Puppet[:certname], {'one'=>'1'})
+    expect(subject.indirection).to receive(:find).with(Puppet[:certname], {'one'=>'1'})
     subject.send(:find, :extra => {'one'=>'1'})
   end
 
@@ -73,7 +73,7 @@ describe Puppet::Indirector::Face do
   end
 
   it "should be able to set its terminus class" do
-    subject.indirection.expects(:terminus_class=).with(:myterm)
+    expect(subject.indirection).to receive(:terminus_class=).with(:myterm)
     subject.set_terminus(:myterm)
   end
 

data/spec/unit/indirector/facts/facter_spec.rb

@@ -1,8 +1,6 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector/facts/facter'
 
-module NodeFactsFacterSpec
 describe Puppet::Node::Facts::Facter do
   FS = Puppet::FileSystem
 
@@ -24,38 +22,35 @@ describe Puppet::Node::Facts::Facter do
   end
 
   before :each do
-    Puppet::Node::Facts::Facter.stubs(:reload_facter)
+    allow(Puppet::Node::Facts::Facter).to receive(:reload_facter)
     @facter = Puppet::Node::Facts::Facter.new
-    Facter.stubs(:to_hash).returns({})
+    allow(Facter).to receive(:to_hash).and_return({})
     @name = "me"
-    @request = stub 'request', :key => @name
-    @environment = stub 'environment'
-    @request.stubs(:environment).returns(@environment)
-    @request.environment.stubs(:modules).returns([])
-    @request.environment.stubs(:modulepath).returns([])
+    @request = double('request', :key => @name)
+    @environment = double('environment')
+    allow(@request).to receive(:environment).and_return(@environment)
+    allow(@request.environment).to receive(:modules).and_return([])
+    allow(@request.environment).to receive(:modulepath).and_return([])
   end
 
   describe 'when finding facts' do
     it 'should reset facts' do
-      reset = sequence 'reset'
-      Facter.expects(:reset).in_sequence(reset)
-      Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)
+      expect(Facter).to receive(:reset).ordered
+      expect(Puppet::Node::Facts::Facter).to receive(:setup_search_paths).ordered
       @facter.find(@request)
     end
 
     it 'should add the puppetversion and agent_specified_environment facts' do
-      reset = sequence 'reset'
-      Facter.expects(:reset).in_sequence(reset)
-      Facter.expects(:add).with(:puppetversion)
-      Facter.expects(:add).with(:agent_specified_environment)
+      expect(Facter).to receive(:reset).ordered
+      expect(Facter).to receive(:add).with(:puppetversion)
+      expect(Facter).to receive(:add).with(:agent_specified_environment)
       @facter.find(@request)
     end
 
     it 'should include external facts' do
-      reset = sequence 'reset'
-      Facter.expects(:reset).in_sequence(reset)
-      Puppet::Node::Facts::Facter.expects(:setup_external_search_paths).in_sequence(reset)
-      Puppet::Node::Facts::Facter.expects(:setup_search_paths).in_sequence(reset)
+      expect(Facter).to receive(:reset).ordered
+      expect(Puppet::Node::Facts::Facter).to receive(:setup_external_search_paths).ordered
+      expect(Puppet::Node::Facts::Facter).to receive(:setup_search_paths).ordered
       @facter.find(@request)
     end
 
@@ -68,23 +63,23 @@ describe Puppet::Node::Facts::Facter do
     end
 
     it "should return the Facter facts as the values in the Facts instance" do
-      Facter.expects(:to_hash).returns("one" => "two")
+      expect(Facter).to receive(:to_hash).and_return("one" => "two")
       facts = @facter.find(@request)
       expect(facts.values["one"]).to eq("two")
     end
 
     it "should add local facts" do
       facts = Puppet::Node::Facts.new("foo")
-      Puppet::Node::Facts.expects(:new).returns facts
-      facts.expects(:add_local_facts)
+      expect(Puppet::Node::Facts).to receive(:new).and_return(facts)
+      expect(facts).to receive(:add_local_facts)
 
       @facter.find(@request)
     end
 
     it "should sanitize facts" do
       facts = Puppet::Node::Facts.new("foo")
-      Puppet::Node::Facts.expects(:new).returns facts
-      facts.expects(:sanitize)
+      expect(Puppet::Node::Facts).to receive(:new).and_return(facts)
+      expect(facts).to receive(:sanitize)
 
       @facter.find(@request)
     end
@@ -107,26 +102,26 @@ describe Puppet::Node::Facts::Facter do
     let(:modulepluginsfacter) { File.expand_path 'module/foo/plugins/facter' }
 
     before :each do
-      FileTest.expects(:directory?).with(factpath1).returns true
-      FileTest.expects(:directory?).with(factpath2).returns true
-      @request.environment.stubs(:modulepath).returns [modulepath]
-      Dir.expects(:glob).with("#{modulepath}/*/lib/facter").returns [modulelibfacter]
-      Dir.expects(:glob).with("#{modulepath}/*/plugins/facter").returns [modulepluginsfacter]
+      expect(FileTest).to receive(:directory?).with(factpath1).and_return(true)
+      expect(FileTest).to receive(:directory?).with(factpath2).and_return(true)
+      allow(@request.environment).to receive(:modulepath).and_return([modulepath])
+      expect(Dir).to receive(:glob).with("#{modulepath}/*/lib/facter").and_return([modulelibfacter])
+      expect(Dir).to receive(:glob).with("#{modulepath}/*/plugins/facter").and_return([modulepluginsfacter])
 
       Puppet[:factpath] = factpath
     end
 
     it 'should skip files' do
-      FileTest.expects(:directory?).with(modulelibfacter).returns false
-      FileTest.expects(:directory?).with(modulepluginsfacter).returns false
-      Facter.expects(:search).with(factpath1, factpath2)
+      expect(FileTest).to receive(:directory?).with(modulelibfacter).and_return(false)
+      expect(FileTest).to receive(:directory?).with(modulepluginsfacter).and_return(false)
+      expect(Facter).to receive(:search).with(factpath1, factpath2)
       Puppet::Node::Facts::Facter.setup_search_paths @request
     end
 
     it 'should add directories' do
-      FileTest.expects(:directory?).with(modulelibfacter).returns true
-      FileTest.expects(:directory?).with(modulepluginsfacter).returns true
-      Facter.expects(:search).with(modulelibfacter, modulepluginsfacter, factpath1, factpath2)
+      expect(FileTest).to receive(:directory?).with(modulelibfacter).and_return(true)
+      expect(FileTest).to receive(:directory?).with(modulepluginsfacter).and_return(true)
+      expect(Facter).to receive(:search).with(modulelibfacter, modulepluginsfacter, factpath1, factpath2)
       Puppet::Node::Facts::Facter.setup_search_paths @request
     end
   end
@@ -137,23 +132,22 @@ describe Puppet::Node::Facts::Facter do
     let(:modulefactsd) { File.expand_path 'module/foo/facts.d'  }
 
     before :each do
-      FileTest.expects(:directory?).with(pluginfactdest).returns true
+      expect(FileTest).to receive(:directory?).with(pluginfactdest).and_return(true)
       mod = Puppet::Module.new('foo', modulepath, @request.environment)
-      @request.environment.stubs(:modules).returns [mod]
+      allow(@request.environment).to receive(:modules).and_return([mod])
       Puppet[:pluginfactdest] = pluginfactdest
     end
 
     it 'should skip files' do
-      File.expects(:directory?).with(modulefactsd).returns false
-      Facter.expects(:search_external).with [pluginfactdest]
+      expect(File).to receive(:directory?).with(modulefactsd).and_return(false)
+      expect(Facter).to receive(:search_external).with([pluginfactdest])
       Puppet::Node::Facts::Facter.setup_external_search_paths @request
     end
 
     it 'should add directories' do
-      File.expects(:directory?).with(modulefactsd).returns true
-      Facter.expects(:search_external).with [modulefactsd, pluginfactdest]
+      expect(File).to receive(:directory?).with(modulefactsd).and_return(true)
+      expect(Facter).to receive(:search_external).with([modulefactsd, pluginfactdest])
       Puppet::Node::Facts::Facter.setup_external_search_paths @request
     end
   end
 end
-end

data/spec/unit/indirector/facts/network_device_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/util/network_device'
@@ -25,11 +24,11 @@ end
 
 describe Puppet::Node::Facts::NetworkDevice do
   before :each do
-    @remote_device = stub 'remote_device', :facts => {}
-    Puppet::Util::NetworkDevice.stubs(:current).returns(@remote_device)
+    @remote_device = double('remote_device', :facts => {})
+    allow(Puppet::Util::NetworkDevice).to receive(:current).and_return(@remote_device)
     @device = Puppet::Node::Facts::NetworkDevice.new
     @name = "me"
-    @request = stub 'request', :key => @name
+    @request = double('request', :key => @name)
   end
 
   describe Puppet::Node::Facts::NetworkDevice, " when finding facts" do
@@ -42,23 +41,23 @@ describe Puppet::Node::Facts::NetworkDevice do
     end
 
     it "should return the device facts as the values in the Facts instance" do
-      @remote_device.expects(:facts).returns("one" => "two")
+      expect(@remote_device).to receive(:facts).and_return("one" => "two")
       facts = @device.find(@request)
       expect(facts.values["one"]).to eq("two")
     end
 
     it "should add local facts" do
       facts = Puppet::Node::Facts.new("foo")
-      Puppet::Node::Facts.expects(:new).returns facts
-      facts.expects(:add_local_facts)
+      expect(Puppet::Node::Facts).to receive(:new).and_return(facts)
+      expect(facts).to receive(:add_local_facts)
 
       @device.find(@request)
     end
 
     it "should sanitize facts" do
       facts = Puppet::Node::Facts.new("foo")
-      Puppet::Node::Facts.expects(:new).returns facts
-      facts.expects(:sanitize)
+      expect(Puppet::Node::Facts).to receive(:new).and_return(facts)
+      expect(facts).to receive(:sanitize)
 
       @device.find(@request)
     end

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

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/facts/rest'
@@ -12,29 +11,29 @@ describe Puppet::Node::Facts::Rest do
   before(:each) { model.indirection.terminus_class = :rest }
 
   def mock_response(code, body, content_type='text/plain', encoding=nil)
-    obj = stub('http response', :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 response', :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
 
   describe '#save' do
     subject { model.indirection.terminus(:rest) }
 
-    let(:connection) { stub('mock http connection', :verify_callback= => nil) }
+    let(:connection) { double('mock http connection', :verify_callback= => nil) }
     let(:node_name) { 'puppet.node.test' }
     let(:data) { model.new(node_name, {test_fact: 'test value'}) }
     let(:request) { Puppet::Indirector::Request.new(:facts, :save, node_name, data) }
 
     before :each do
-      subject.stubs(:network).returns(connection)
+      allow(subject).to receive(:network).and_return(connection)
     end
 
     context 'when a 404 response is received' do
       let(:response) { mock_response(404, '{}', 'test/json') }
 
-      before(:each) { connection.expects(:put).returns response }
+      before(:each) { expect(connection).to receive(:put).and_return(response) }
 
       it 'riases with HTTP 404' do
         expect{ subject.save(request) }.to raise_error(Net::HTTPError,

data/spec/unit/indirector/facts/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/facts/yaml_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/node/facts'
@@ -33,10 +32,10 @@ describe Puppet::Node::Facts::Yaml do
     def assert_search_matches(matching, nonmatching, query)
       request = Puppet::Indirector::Request.new(:inventory, :search, nil, nil, query)
 
-      Dir.stubs(:glob).returns(matching.keys + nonmatching.keys)
+      allow(Dir).to receive(:glob).and_return(matching.keys + nonmatching.keys)
       [matching, nonmatching].each do |examples|
         examples.each do |key, value|
-          YAML.stubs(:load_file).with(key).returns value
+          allow(YAML).to receive(:load_file).with(key).and_return(value)
         end
       end
       expect(Puppet::Node::Facts::Yaml.new.search(request)).to match_array(matching.values.map {|facts| facts.name})
@@ -68,7 +67,6 @@ describe Puppet::Node::Facts::Yaml do
       )
     end
 
-
     it "should return node names that match the search query options with the greater than operator" do
       assert_search_matches({
           '/path/to/matching.yaml'  => Puppet::Node::Facts.new("matchingnode",  "architecture" => "i386",    'processor_count' => '5'),

data/spec/unit/indirector/file_bucket_file/file_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/file'
@@ -55,7 +54,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         checksum_value = save_bucket_file(first_contents, "/foo/bar")
 
         # We expect Puppet to log an error with the path to the file
-        Puppet.expects(:err).with(regexp_matches(/Unable to verify existing FileBucket backup at '#{Puppet[:bucketdir]}.*#{checksum_value}\/contents'/))
+        expect(Puppet).to receive(:err).with(/Unable to verify existing FileBucket backup at '#{Puppet[:bucketdir]}.*#{checksum_value}\/contents'/)
 
         # But the exception should not contain it
         expect do
@@ -80,7 +79,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         end
 
         it "issues a warning that the backup will be overwritten" do
-          Puppet.expects(:warning).with(regexp_matches(/Existing backup does not match its expected sum, #{bucket_file.checksum}/))
+          expect(Puppet).to receive(:warning).with(/Existing backup does not match its expected sum, #{bucket_file.checksum}/)
           Puppet::FileBucket::File.indirection.save(bucket_file)
         end
 
@@ -338,7 +337,7 @@ describe Puppet::FileBucketFile::File, :uses_checksums => true do
         describe "when #{supply_path ? 'supplying' : 'not supplying'} a path" do
           with_digest_algorithms do
             before :each do
-              Puppet.settings.stubs(:use)
+              allow(Puppet.settings).to receive(:use)
               @store = Puppet::FileBucketFile::File.new
 
               @bucket_top_dir = tmpdir("bucket")

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

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

data/spec/unit/indirector/file_bucket_file/selector_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/selector'
@@ -9,17 +8,17 @@ describe Puppet::FileBucketFile::Selector do
   %w[head find save search destroy].each do |method|
     describe "##{method}" do
       it "should proxy to rest terminus for https requests" do
-        request = stub 'request', :protocol => 'https'
+        request = double('request', :protocol => 'https')
 
-        Puppet::FileBucketFile::Rest.any_instance.expects(method).with(request)
+        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(method).with(request)
 
         subject.send(method, request)
       end
 
       it "should proxy to file terminus for other requests" do
-        request = stub 'request', :protocol => 'file'
+        request = double('request', :protocol => 'file')
 
-        Puppet::FileBucketFile::File.any_instance.expects(method).with(request)
+        expect_any_instance_of(Puppet::FileBucketFile::File).to receive(method).with(request)
 
         subject.send(method, request)
       end

data/spec/unit/indirector/file_content/file_server_spec.rb

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

data/spec/unit/indirector/file_content/file_spec.rb

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

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

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

data/spec/unit/indirector/file_content/selector_spec.rb

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

data/spec/unit/indirector/file_metadata/file_server_spec.rb

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

data/spec/unit/indirector/file_metadata/file_spec.rb

@@ -1,4 +1,3 @@
-#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_metadata/file'
@@ -17,17 +16,17 @@ describe Puppet::Indirector::FileMetadata::File do
       @metadata = Puppet::Indirector::FileMetadata::File.new
       @path = File.expand_path('/my/local')
       @uri = Puppet::Util.path_to_uri(@path).to_s
-      @data = mock 'metadata'
-      @data.stubs(:collect)
-      Puppet::FileSystem.expects(:exist?).with(@path).returns true
+      @data = double('metadata')
+      allow(@data).to receive(:collect)
+      expect(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
 
       @request = Puppet::Indirector::Request.new(:file_metadata, :find, @uri, nil)
     end
 
     it "should collect its attributes when a file is found" do
-      @data.expects(:collect)
+      expect(@data).to receive(:collect)
 
-      Puppet::FileServing::Metadata.expects(:new).returns(@data)
+      expect(Puppet::FileServing::Metadata).to receive(:new).and_return(@data)
       expect(@metadata.find(@request)).to eq(@data)
     end
   end
@@ -42,15 +41,15 @@ describe Puppet::Indirector::FileMetadata::File do
     end
 
     it "should collect the attributes of the instances returned" do
-      Puppet::FileSystem.expects(:exist?).with(@path).returns true
-      Puppet::FileServing::Fileset.expects(:new).with(@path, @request).returns mock("fileset")
-      Puppet::FileServing::Fileset.expects(:merge).returns [["one", @path], ["two", @path]]
+      expect(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
+      expect(Puppet::FileServing::Fileset).to receive(:new).with(@path, @request).and_return(double("fileset"))
+      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return([["one", @path], ["two", @path]])
 
-      one = mock("one", :collect => nil)
-      Puppet::FileServing::Metadata.expects(:new).with(@path, {:relative_path => "one"}).returns one
+      one = double("one", :collect => nil)
+      expect(Puppet::FileServing::Metadata).to receive(:new).with(@path, {:relative_path => "one"}).and_return(one)
 
-      two = mock("two", :collect => nil)
-      Puppet::FileServing::Metadata.expects(:new).with(@path, {:relative_path => "two"}).returns two
+      two = double("two", :collect => nil)
+      expect(Puppet::FileServing::Metadata).to receive(:new).with(@path, {:relative_path => "two"}).and_return(two)
 
       expect(@metadata.search(@request)).to eq([one, two])
     end