puppet 6.0.10 → 6.1.0

data/spec/unit/indirector/json_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet/indirector/indirector_testing/json'
@@ -16,19 +17,19 @@ describe Puppet::Indirector::JSON do
     end
 
     it "uses the :server_datadir setting if this is the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      Puppet.run_mode.stubs(:master?).returns(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.json')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "uses the :client_datadir setting if this is not the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(false)
+      Puppet.run_mode.stubs(:master?).returns(false)
       expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.json')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "overrides the default extension with a supplied value" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      Puppet.run_mode.stubs(:master?).returns(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-json')
       expect(subject.path('testing', '.not-json')).to eq(expected)
     end
@@ -50,7 +51,7 @@ describe Puppet::Indirector::JSON do
 
   context "handling requests" do
     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'))
     end
@@ -80,7 +81,7 @@ describe Puppet::Indirector::JSON do
           # I don't like this, but there isn't a credible alternative that
           # also works on Windows, so a stub it is. At least the expectation
           # will fail if the implementation changes. Sorry to the next dev.
-          expect(Puppet::FileSystem).to receive(:read).with(file, anything).and_raise(Errno::EPERM)
+          Puppet::FileSystem.expects(:read).with(file, anything).raises(Errno::EPERM)
           expect { subject.find(request) }.
             to raise_error Puppet::Error, /Could not read JSON/
         end
@@ -148,17 +149,18 @@ describe Puppet::Indirector::JSON do
       end
 
       it "raises an informative error for other failures" do
-        allow(Puppet::FileSystem).to receive(:unlink).with(file).and_raise(Errno::EPERM, 'fake permission problem')
+        Puppet::FileSystem.stubs(:unlink).with(file).raises(Errno::EPERM, 'fake permission problem')
         with_content('hello') do
           expect { subject.destroy(request) }.to raise_error(Puppet::Error)
         end
+        Puppet::FileSystem.unstub(:unlink)    # thanks, mocha
       end
     end
   end
 
   context "#search" do
     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'))
     end

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/key/file'
@@ -16,10 +17,10 @@ describe Puppet::SSL::Key::File do
     it "should use the host name plus '.pem' in :publickeydir for normal hosts" do
       Puppet[:privatekeydir] = File.expand_path("/private/key/dir")
       Puppet[:publickeydir] = File.expand_path("/public/key/dir")
-      allow(Puppet.settings).to receive(:use)
+      Puppet.settings.stubs(:use)
 
       @searcher = Puppet::SSL::Key::File.new
-      allow(@searcher).to receive(:ca?).and_return(false)
+      @searcher.stubs(:ca?).returns false
       expect(@searcher.public_key_path("whatever")).to eq(File.expand_path("/public/key/dir/whatever.pem"))
     end
   end
@@ -31,26 +32,26 @@ describe Puppet::SSL::Key::File do
       @private_key_path = File.join("/fake/key/path")
       @public_key_path = File.join("/other/fake/key/path")
 
-      allow(@searcher).to receive(:public_key_path).and_return(@public_key_path)
-      allow(@searcher).to receive(:path).and_return(@private_key_path)
+      @searcher.stubs(:public_key_path).returns @public_key_path
+      @searcher.stubs(:path).returns @private_key_path
 
-      allow(FileTest).to receive(:directory?).and_return(true)
-      allow(FileTest).to receive(:writable?).and_return(true)
+      FileTest.stubs(:directory?).returns true
+      FileTest.stubs(:writable?).returns true
 
-      @public_key = double('public_key')
-      @real_key = double('sslkey', :public_key => @public_key)
+      @public_key = stub 'public_key'
+      @real_key = stub 'sslkey', :public_key => @public_key
 
-      @key = double('key', :name => "myname", :content => @real_key)
+      @key = stub 'key', :name => "myname", :content => @real_key
 
-      @request = double('request', :key => "myname", :instance => @key)
+      @request = stub 'request', :key => "myname", :instance => @key
     end
 
     it "should save the public key when saving the private key" do
       fh = StringIO.new
 
-      expect(Puppet.settings.setting(:publickeydir)).to receive(:open_file).with(@public_key_path, 'w:ASCII').and_yield(fh)
-      allow(Puppet.settings.setting(:privatekeydir)).to receive(:open_file)
-      expect(@public_key).to receive(:to_pem).and_return("my pem")
+      Puppet.settings.setting(:publickeydir).expects(:open_file).with(@public_key_path, 'w:ASCII').yields fh
+      Puppet.settings.setting(:privatekeydir).stubs(:open_file)
+      @public_key.expects(:to_pem).returns "my pem"
 
       @searcher.save(@request)
 
@@ -58,20 +59,20 @@ describe Puppet::SSL::Key::File do
     end
 
     it "should destroy the public key when destroying the private key" do
-      expect(Puppet::FileSystem).to receive(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
-      expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).and_return(true)
-      expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).and_return(true)
-      expect(Puppet::FileSystem).to receive(:unlink).with(Puppet::FileSystem.pathname(@public_key_path))
+      Puppet::FileSystem.expects(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
+      Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).returns true
+      Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).returns true
+      Puppet::FileSystem.expects(:unlink).with(Puppet::FileSystem.pathname(@public_key_path))
 
       @searcher.destroy(@request)
     end
 
     it "should not fail if the public key does not exist when deleting the private key" do
-      allow(Puppet::FileSystem).to receive(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
+      Puppet::FileSystem.stubs(:unlink).with(Puppet::FileSystem.pathname(@private_key_path))
 
-      allow(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).and_return(true)
-      expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).and_return(false)
-      expect(Puppet::FileSystem).not_to receive(:unlink).with(Puppet::FileSystem.pathname(@public_key_path))
+      Puppet::FileSystem.stubs(:exist?).with(Puppet::FileSystem.pathname(@private_key_path)).returns true
+      Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@public_key_path)).returns false
+      Puppet::FileSystem.expects(:unlink).with(Puppet::FileSystem.pathname(@public_key_path)).never
 
       @searcher.destroy(@request)
     end

data/spec/unit/indirector/memory_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/indirector/memory'
 
@@ -7,10 +8,10 @@ describe Puppet::Indirector::Memory do
   it_should_behave_like "A Memory Terminus"
 
   before do
-    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)
+    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)
 
     module Testing; end
     @memory_class = class Testing::MyMemory < Puppet::Indirector::Memory
@@ -19,8 +20,8 @@ describe Puppet::Indirector::Memory do
 
     @searcher = @memory_class.new
     @name = "me"
-    @instance = double('instance', :name => @name)
+    @instance = stub 'instance', :name => @name
 
-    @request = double('request', :key => @name, :instance => @instance)
+    @request = stub 'request', :key => @name, :instance => @instance
   end
 end

data/spec/unit/indirector/msgpack_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet_spec/files'
 require 'puppet/indirector/indirector_testing/msgpack'
@@ -16,19 +17,19 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
     end
 
     it "uses the :server_datadir setting if this is the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      Puppet.run_mode.stubs(:master?).returns(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.msgpack')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "uses the :client_datadir setting if this is not the master" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(false)
+      Puppet.run_mode.stubs(:master?).returns(false)
       expected = File.join(Puppet[:client_datadir], 'indirector_testing', 'testing.msgpack')
       expect(subject.path('testing')).to eq(expected)
     end
 
     it "overrides the default extension with a supplied value" do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      Puppet.run_mode.stubs(:master?).returns(true)
       expected = File.join(Puppet[:server_datadir], 'indirector_testing', 'testing.not-msgpack')
       expect(subject.path('testing', '.not-msgpack')).to eq(expected)
     end
@@ -50,7 +51,7 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
 
   context "handling requests" do
     before :each do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      Puppet.run_mode.stubs(:master?).returns(true)
       Puppet[:server_datadir] = tmpdir('msgpackdir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
     end
@@ -90,7 +91,7 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
           # I don't like this, but there isn't a credible alternative that
           # also works on Windows, so a stub it is. At least the expectation
           # will fail if the implementation changes. Sorry to the next dev.
-          expect(Puppet::FileSystem).to receive(:read).with(file, {:encoding => 'utf-8'}).and_raise(Errno::EPERM)
+          Puppet::FileSystem.expects(:read).with(file, {:encoding => 'utf-8'}).raises(Errno::EPERM)
           expect { subject.find(request) }.
             to raise_error Puppet::Error, /Could not read MessagePack/
         end
@@ -148,17 +149,18 @@ describe Puppet::Indirector::Msgpack, :if => Puppet.features.msgpack? do
       end
 
       it "raises an informative error for other failures" do
-        allow(Puppet::FileSystem).to receive(:unlink).with(file).and_raise(Errno::EPERM, 'fake permission problem')
+        Puppet::FileSystem.stubs(:unlink).with(file).raises(Errno::EPERM, 'fake permission problem')
         with_content('hello') do
           expect { subject.destroy(request) }.to raise_error(Puppet::Error)
         end
+        Puppet::FileSystem.unstub(:unlink)    # thanks, mocha
       end
     end
   end
 
   context "#search" do
     before :each do
-      allow(Puppet.run_mode).to receive(:master?).and_return(true)
+      Puppet.run_mode.stubs(:master?).returns(true)
       Puppet[:server_datadir] = tmpdir('msgpackdir')
       FileUtils.mkdir_p(File.join(Puppet[:server_datadir], 'indirector_testing'))
     end

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

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/node/exec'
@@ -19,7 +20,7 @@ describe Puppet::Node::Exec do
 
     it "should throw an exception if no external node command is set" do
       Puppet[:external_nodes] = "none"
-      expect { searcher.find(double('request', :key => "foo")) }.to raise_error(ArgumentError)
+      expect { searcher.find(stub('request', :key => "foo")) }.to raise_error(ArgumentError)
     end
   end
 
@@ -31,7 +32,7 @@ describe Puppet::Node::Exec do
     let(:facts) { Puppet::Node::Facts.new(name, {}) }
 
     before do
-      allow(Puppet::Node::Facts.indirection).to receive(:find).and_return(facts)
+      Puppet::Node::Facts.indirection.stubs(:find).returns(facts)
 
       @result = {}
       # Use a local variable so the reference is usable in the execute definition.

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

@@ -1,15 +1,17 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/node/memory'
+
 require 'shared_behaviours/memory_terminus'
 
 describe Puppet::Node::Memory do
   before do
     @name = "me"
     @searcher = Puppet::Node::Memory.new
-    @instance = double('instance', :name => @name)
+    @instance = stub 'instance', :name => @name
 
-    @request = double('request', :key => @name, :instance => @instance)
+    @request = stub 'request', :key => @name, :instance => @instance
   end
 
   it_should_behave_like "A Memory Terminus"

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

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

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

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

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

@@ -1,3 +1,4 @@
+#! /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
-    allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
-    allow(Puppet::Indirector::Indirection).to receive(:instance).and_return(indirection)
+    Puppet::Indirector::Terminus.stubs(:register_terminus_class)
+    Puppet::Indirector::Indirection.stubs(:instance).returns(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)   { double('model') }
-  let(:request) { double('request', :key => "port") }
+  let(:model)   { mock('model') }
+  let(:request) { stub('request', :key => "port") }
   let(:indirection) do
-    double('indirection', :name => :none, :register_terminus_type => nil,
+    stub('indirection', :name => :none, :register_terminus_type => nil,
       :model => model)
   end
 

data/spec/unit/indirector/plain_spec.rb

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

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

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

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

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