puppet 6.0.10-x64-mingw32 → 6.1.0-x64-mingw32

data/spec/unit/indirector/catalog/json_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet/resource/catalog'
@@ -24,7 +25,7 @@ describe Puppet::Resource::Catalog::Json do
     end
 
     before :each do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      Puppet.run_mode.stubs(:master?).returns(true)
       Puppet[:server_datadir] = tmpdir('jsondir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
       Puppet.push_context(:loaders => Puppet::Pops::Loaders.new(env))

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/resource/catalog'
 require 'puppet/indirector/catalog/msgpack'

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

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

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

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

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

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

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

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

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

@@ -1,4 +1,6 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
+
 require 'puppet/indirector/certificate/rest'
 
 describe Puppet::SSL::Certificate::Rest do
@@ -43,15 +45,15 @@ rn/G
 -----END CERTIFICATE-----
 "
 
-    network = double('network')
-    allow(terminus).to receive(:network).and_return(network)
+    network = stub 'network'
+    terminus.stubs(:network).returns network
 
-    response = double('response', :code => "200", :body => cert_string)
-    allow(response).to receive(:[]).with('content-type').and_return("text/plain")
-    allow(response).to receive(:[]).with('content-encoding')
-    allow(response).to receive(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).and_return(Puppet.version)
-    allow(network).to receive(:verify_callback=)
-    expect(network).to receive(:get).and_return(response)
+    response = stub 'response', :code => "200", :body => cert_string
+    response.stubs(:[]).with('content-type').returns "text/plain"
+    response.stubs(:[]).with('content-encoding')
+    response.stubs(:[]).with(Puppet::Network::HTTP::HEADER_PUPPET_VERSION).returns(Puppet.version)
+    network.stubs(:verify_callback=)
+    network.expects(:get).returns response
 
     request = Puppet::Indirector::Request.new(:certificate, :find, "foo.com", nil)
     result = terminus.find(request)

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

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

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

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

data/spec/unit/indirector/direct_file_server_spec.rb

@@ -1,9 +1,10 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/direct_file_server'
 
 describe Puppet::Indirector::DirectFileServer do
-  before(:each) do
+  before :all do
     class Puppet::FileTestModel
       extend Puppet::Indirector
       indirects :file_test_model
@@ -25,48 +26,48 @@ describe Puppet::Indirector::DirectFileServer do
   let(:indirection) { Puppet::FileTestModel.indirection }
   let(:model) { Puppet::FileTestModel }
 
-  after(:each) do
+  after(:all) do
     Puppet::FileTestModel.indirection.delete
     Puppet.send(:remove_const, :FileTestModel)
   end
 
   describe "when finding a single file" do
     it "should return nil if the file does not exist" do
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
+      Puppet::FileSystem.expects(:exist?).with(path).returns(false)
       expect(indirection.find(path)).to be_nil
     end
 
     it "should return a Content instance created with the full path to the file if the file exists" do
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-      mycontent = double('content', :collect => nil)
-      expect(mycontent).to receive(:collect)
-      expect(model).to receive(:new).and_return(mycontent)
+      Puppet::FileSystem.expects(:exist?).with(path).returns(true)
+      mycontent = stub 'content', :collect => nil
+      mycontent.expects(:collect)
+      model.expects(:new).returns(mycontent)
       expect(indirection.find(path)).to eq(mycontent)
     end
   end
 
   describe "when creating the instance for a single found file" do
-    let(:data) { double('content', collect: nil) }
+    let(:data) { stub('content', collect: nil) }
 
     before(:each) do
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
+      Puppet::FileSystem.expects(:exist?).with(path).returns(true)
     end
 
     it "should pass the full path to the instance" do
-      expect(model).to receive(:new).with(path, anything).and_return(data)
+      model.expects(:new).with { |key, options| key == path }.returns(data)
       indirection.find(path)
     end
 
     it "should pass the :links setting on to the created Content instance if the file exists and there is a value for :links" do
-      expect(model).to receive(:new).and_return(data)
-      expect(data).to receive(:links=).with(:manage)
+      model.expects(:new).returns(data)
+      data.expects(:links=).with(:manage)
 
       indirection.find(path, links: :manage)
     end
 
     it "should set 'checksum_type' on the instances if it is set in the request options" do
-      expect(model).to receive(:new).and_return(data)
-      expect(data).to receive(:checksum_type=).with(:checksum)
+      model.expects(:new).returns(data)
+      data.expects(:checksum_type=).with(:checksum)
 
       indirection.find(path, checksum_type: :checksum)
     end
@@ -74,13 +75,13 @@ describe Puppet::Indirector::DirectFileServer do
 
   describe "when searching for multiple files" do
     it "should return nil if the file does not exist" do
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(false)
+      Puppet::FileSystem.expects(:exist?).with(path).returns(false)
       expect(indirection.search(path)).to be_nil
     end
 
     it "should pass the original request to :path2instances" do
-      expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-      expect(terminus).to receive(:path2instances).with(anything, path)
+      Puppet::FileSystem.expects(:exist?).with(path).returns(true)
+      terminus.expects(:path2instances).with(anything, path)
       indirection.search(path)
     end
   end

data/spec/unit/indirector/envelope_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector/envelope'
 
@@ -24,7 +25,7 @@ describe Puppet::Indirector::Envelope do
 
     it "should return false if the current date is equal to the expiration date" do
       now = Time.now
-      allow(Time).to receive(:now).and_return(now)
+      Time.stubs(:now).returns(now)
       @instance.expiration = now
       expect(@instance).not_to be_expired
     end

data/spec/unit/indirector/exec_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/exec'
@@ -40,22 +41,22 @@ describe Puppet::Indirector::Exec do
   end
 
   it "should execute the command with the object name as the only argument" do
-    expect(terminus).to receive(:execute).with([path, 'foo'], arguments)
+    terminus.expects(:execute).with([path, 'foo'], arguments)
     indirection.find('foo')
   end
 
   it "should return the output of the script" do
-    expect(terminus).to receive(:execute).with([path, 'foo'], arguments).and_return("whatever")
+    terminus.expects(:execute).with([path, 'foo'], arguments).returns("whatever")
     expect(indirection.find('foo')).to eq("whatever")
   end
 
   it "should return nil when the command produces no output" do
-    expect(terminus).to receive(:execute).with([path, 'foo'], arguments).and_return(nil)
+    terminus.expects(:execute).with([path, 'foo'], arguments).returns(nil)
     expect(indirection.find('foo')).to be_nil
   end
 
   it "should raise an exception if there's an execution failure" do
-    expect(terminus).to receive(:execute).with([path, 'foo'], arguments).and_raise(Puppet::ExecutionFailure.new("message"))
+    terminus.expects(:execute).with([path, 'foo'], arguments).raises(Puppet::ExecutionFailure.new("message"))
     expect {
       indirection.find('foo')
     }.to raise_exception(Puppet::Error, 'Failed to find foo via exec: message')

data/spec/unit/indirector/face_spec.rb

@@ -1,13 +1,14 @@
+#! /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 = double('indirection',
+    indirection = stub('indirection',
                        :name => :stub_indirection,
                        :reset_terminus_class => nil)
-    allow(instance).to receive(:indirection).and_return(indirection)
+    instance.stubs(:indirection).returns indirection
     instance
   end
 
@@ -18,7 +19,7 @@ describe Puppet::Indirector::Face do
   end
 
   it "should return the sorted to_s list of terminus classes" do
-    expect(Puppet::Indirector::Terminus).to receive(:terminus_classes).and_return([
+    Puppet::Indirector::Terminus.expects(:terminus_classes).returns([
       :yaml,
       :compiler,
       :rest
@@ -33,7 +34,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
-      allow(Puppet::Face).to receive(:load_actions)
+      Puppet::Face.stubs(:load_actions)
       expect(Puppet::Indirector::Face.new(:catalog, '0.0.1').indirection).to equal(Puppet::Resource::Catalog.indirection)
     end
   end
@@ -52,18 +53,17 @@ describe Puppet::Indirector::Face do
     end
 
     it "should call the indirection method with options when the '#{method}' action is invoked" do
-      expect(subject.indirection).to receive(method).with(:test, *params(method, {}))
+      subject.indirection.expects(method).with(:test, *params(method, {}))
       subject.send(method, :test)
     end
-
     it "should forward passed options" do
-      expect(subject.indirection).to receive(method).with(:test, *params(method, {'one'=>'1'}))
+      subject.indirection.expects(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
-    expect(subject.indirection).to receive(:find).with(Puppet[:certname], {'one'=>'1'})
+    subject.indirection.expects(: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
-    expect(subject.indirection).to receive(:terminus_class=).with(:myterm)
+    subject.indirection.expects(:terminus_class=).with(:myterm)
     subject.set_terminus(:myterm)
   end
 

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

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