puppet 5.5.22-x86-mingw32 → 6.0.0-x86-mingw32

data/spec/unit/indirector/ssl_file_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/ssl_file'
@@ -5,18 +6,30 @@ require 'puppet/indirector/ssl_file'
 describe Puppet::Indirector::SslFile do
   include PuppetSpec::Files
 
-  before :each do
-    @indirection = Puppet::Indirector::Indirection.new(nil, :testing)
+  before(:all) do
+    class Puppet::SslTestModel
+      extend Puppet::Indirector
+      indirects :ssl_test_model
+    end
 
-    module Testing; end
-    @file_class = class Testing::MyType < Puppet::Indirector::SslFile
-      self
+    class Puppet::SslTestModel::SslFile < Puppet::Indirector::SslFile
     end
 
+    Puppet::SslTestModel.indirection.terminus_class = :ssl_file
+  end
+
+  after(:all) do
+    Puppet::SslTestModel.indirection.delete
+    Puppet.send(:remove_const, :SslTestModel)
+  end
+
+  let(:terminus_class) { Puppet::SslTestModel::SslFile }
+  let(:model) { Puppet::SslTestModel }
+
+  before :each do
     @setting = :certdir
-    @file_class.store_in @setting
-    @file_class.store_at nil
-    @file_class.store_ca_at nil
+    terminus_class.store_in @setting
+    terminus_class.store_at nil
     @path = make_absolute("/thisdoesntexist/my_directory")
     Puppet[:noop] = false
     Puppet[@setting] = @path
@@ -24,71 +37,53 @@ describe Puppet::Indirector::SslFile do
   end
 
   after :each do
-    @file_class.store_in nil
-    @file_class.store_at nil
-    @file_class.store_ca_at nil
-    @indirection.delete
+    terminus_class.store_in nil
+    terminus_class.store_at nil
   end
 
   it "should use :main and :ssl upon initialization" do
-    expect(Puppet.settings).to receive(:use).with(:main, :ssl)
-    @file_class.new
+    Puppet.settings.expects(:use).with(:main, :ssl)
+    terminus_class.new
   end
 
   it "should return a nil collection directory if no directory setting has been provided" do
-    @file_class.store_in nil
-    expect(@file_class.collection_directory).to be_nil
+    terminus_class.store_in nil
+    expect(terminus_class.collection_directory).to be_nil
   end
 
   it "should return a nil file location if no location has been provided" do
-    @file_class.store_at nil
-    expect(@file_class.file_location).to be_nil
+    terminus_class.store_at nil
+    expect(terminus_class.file_location).to be_nil
   end
 
   it "should fail if no store directory or file location has been set" do
-    expect(Puppet.settings).to receive(:use).with(:main, :ssl)
-    @file_class.store_in nil
-    @file_class.store_at nil
+    Puppet.settings.expects(:use).with(:main, :ssl)
+    terminus_class.store_in nil
+    terminus_class.store_at nil
     expect {
-      @file_class.new
+      terminus_class.new
     }.to raise_error(Puppet::DevError, /No file or directory setting provided/)
   end
 
   describe "when managing ssl files" do
     before do
-      allow(Puppet.settings).to receive(:use)
-      @searcher = @file_class.new
+      Puppet.settings.stubs(:use)
+      @searcher = terminus_class.new
 
-      @cert = double('certificate', :name => "myname")
+      @cert = stub 'certificate', :name => "myname"
       @certpath = File.join(@path, "myname.pem")
 
-      @request = double('request', :key => @cert.name, :instance => @cert)
-    end
-
-    it "should consider the file a ca file if the name is equal to what the SSL::Host class says is the CA name" do
-      expect(Puppet::SSL::Host).to receive(:ca_name).and_return("amaca")
-      expect(@searcher).to be_ca("amaca")
+      @request = stub 'request', :key => @cert.name, :instance => @cert
     end
 
     describe "when choosing the location for certificates" do
-      it "should set them at the ca setting's path if a ca setting is available and the name resolves to the CA name" do
-        @file_class.store_in nil
-        @file_class.store_at :mysetting
-        @file_class.store_ca_at :cakey
-
-        Puppet[:cakey] = File.expand_path("/ca/file")
-
-        expect(@searcher).to receive(:ca?).with(@cert.name).and_return(true)
-        expect(@searcher.path(@cert.name)).to eq(Puppet[:cakey])
-      end
-
       it "should set them at the file location if a file setting is available" do
-        @file_class.store_in nil
-        @file_class.store_at :cacrl
+        terminus_class.store_in nil
+        terminus_class.store_at :hostcrl
 
-        Puppet[:cacrl] = File.expand_path("/some/file")
+        Puppet[:hostcrl] = File.expand_path("/some/file")
 
-        expect(@searcher.path(@cert.name)).to eq(Puppet[:cacrl])
+        expect(@searcher.path(@cert.name)).to eq(Puppet[:hostcrl])
       end
 
       it "should set them in the setting directory, with the certificate name plus '.pem', if a directory setting is available" do
@@ -118,28 +113,28 @@ describe Puppet::Indirector::SslFile do
     describe "when finding certificates on disk" do
       describe "and no certificate is present" do
         it "should return nil" do
-          expect(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(true)
-          expect(Dir).to receive(:entries).with(@path).and_return([])
-          expect(Puppet::FileSystem).to receive(:exist?).with(@certpath).and_return(false)
+          Puppet::FileSystem.expects(:exist?).with(@path).returns(true)
+          Dir.expects(:entries).with(@path).returns([])
+          Puppet::FileSystem.expects(:exist?).with(@certpath).returns(false)
 
           expect(@searcher.find(@request)).to be_nil
         end
       end
 
       describe "and a certificate is present" do
-        let(:cert) { double('cert') }
-        let(:model) { double('model') }
+        let(:cert) { mock 'cert' }
+        let(:model) { mock 'model' }
 
         before(:each) do
-          allow(@file_class).to receive(:model).and_return(model)
+          terminus_class.stubs(:model).returns model
         end
 
         context "is readable" do
           it "should return an instance of the model, which it should use to read the certificate" do
-            expect(Puppet::FileSystem).to receive(:exist?).with(@certpath).and_return(true)
+            Puppet::FileSystem.expects(:exist?).with(@certpath).returns true
 
-            expect(model).to receive(:new).with("myname").and_return(cert)
-            expect(cert).to receive(:read).with(@certpath)
+            model.expects(:new).with("myname").returns cert
+            cert.expects(:read).with(@certpath)
 
             expect(@searcher.find(@request)).to equal(cert)
           end
@@ -147,10 +142,10 @@ describe Puppet::Indirector::SslFile do
 
         context "is unreadable" do
           it "should raise an exception" do
-            expect(Puppet::FileSystem).to receive(:exist?).with(@certpath).and_return(true)
+            Puppet::FileSystem.expects(:exist?).with(@certpath).returns(true)
 
-            expect(model).to receive(:new).with("myname").and_return(cert)
-            expect(cert).to receive(:read).with(@certpath).and_raise(Errno::EACCES)
+            model.expects(:new).with("myname").returns cert
+            cert.expects(:read).with(@certpath).raises(Errno::EACCES)
 
             expect {
               @searcher.find(@request)
@@ -161,25 +156,25 @@ describe Puppet::Indirector::SslFile do
 
       describe "and a certificate is present but has uppercase letters" do
         before do
-          @request = double('request', :key => "myhost")
+          @request = stub 'request', :key => "myhost"
         end
 
         # This is kind of more an integration test; it's for #1382, until
         # the support for upper-case certs can be removed around mid-2009.
         it "should rename the existing file to the lower-case path" do
           @path = @searcher.path("myhost")
-          expect(Puppet::FileSystem).to receive(:exist?).with(@path).and_return(false)
+          Puppet::FileSystem.expects(:exist?).with(@path).returns(false)
           dir, file = File.split(@path)
-          expect(Puppet::FileSystem).to receive(:exist?).with(dir).and_return(true)
-          expect(Dir).to receive(:entries).with(dir).and_return([".", "..", "something.pem", file.upcase])
+          Puppet::FileSystem.expects(:exist?).with(dir).returns true
+          Dir.expects(:entries).with(dir).returns [".", "..", "something.pem", file.upcase]
 
-          expect(File).to receive(:rename).with(File.join(dir, file.upcase), @path)
+          File.expects(:rename).with(File.join(dir, file.upcase), @path)
 
-          cert = double('cert')
-          model = double('model')
-          allow(@searcher).to receive(:model).and_return(model)
-          expect(@searcher.model).to receive(:new).with("myhost").and_return(cert)
-          expect(cert).to receive(:read).with(@path)
+          cert = mock 'cert'
+          model = mock 'model'
+          @searcher.stubs(:model).returns model
+          @searcher.model.expects(:new).with("myhost").returns cert
+          cert.expects(:read).with(@path)
 
           @searcher.find(@request)
         end
@@ -188,27 +183,27 @@ describe Puppet::Indirector::SslFile do
 
     describe "when saving certificates to disk" do
       before do
-        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
       end
 
       it "should fail if the directory is absent" do
-        expect(FileTest).to receive(:directory?).with(File.dirname(@certpath)).and_return(false)
+        FileTest.expects(:directory?).with(File.dirname(@certpath)).returns false
         expect { @searcher.save(@request) }.to raise_error(Puppet::Error)
       end
 
       it "should fail if the directory is not writeable" do
-        allow(FileTest).to receive(:directory?).and_return(true)
-        expect(FileTest).to receive(:writable?).with(File.dirname(@certpath)).and_return(false)
+        FileTest.stubs(:directory?).returns true
+        FileTest.expects(:writable?).with(File.dirname(@certpath)).returns false
         expect { @searcher.save(@request) }.to raise_error(Puppet::Error)
       end
 
       it "should save to the path the output of converting the certificate to a string" do
-        fh = double('filehandle')
-        expect(fh).to receive(:print).with("mycert")
+        fh = mock 'filehandle'
+        fh.expects(:print).with("mycert")
 
-        allow(@searcher).to receive(:write).and_yield(fh)
-        expect(@cert).to receive(:to_s).and_return("mycert")
+        @searcher.stubs(:write).yields fh
+        @cert.expects(:to_s).returns "mycert"
 
         @searcher.save(@request)
       end
@@ -216,9 +211,9 @@ describe Puppet::Indirector::SslFile do
       describe "and a directory setting is set" do
         it "should use the Settings class to write the file" do
           @searcher.class.store_in @setting
-          fh = double('filehandle')
-          allow(fh).to receive(:print)
-          expect(Puppet.settings.setting(@setting)).to receive(:open_file).with(@certpath, 'w:ASCII').and_yield(fh)
+          fh = mock 'filehandle'
+          fh.stubs :print
+          Puppet.settings.setting(@setting).expects(:open_file).with(@certpath, 'w:ASCII').yields fh
 
           @searcher.save(@request)
         end
@@ -228,23 +223,9 @@ describe Puppet::Indirector::SslFile do
         it "should use the filehandle provided by the Settings" do
           @searcher.class.store_at @setting
 
-          fh = double('filehandle')
-          allow(fh).to receive(:print)
-          expect(Puppet.settings.setting(@setting)).to receive(:open).with('w:ASCII').and_yield(fh)
-          @searcher.save(@request)
-        end
-      end
-
-      describe "and the name is the CA name and a ca setting is set" do
-        it "should use the filehandle provided by the Settings" do
-          @searcher.class.store_at @setting
-          @searcher.class.store_ca_at :cakey
-          Puppet[:cakey] = "castuff stub"
-
-          fh = double('filehandle')
-          allow(fh).to receive(:print)
-          expect(Puppet.settings.setting(:cakey)).to receive(:open).with('w:ASCII').and_yield(fh)
-          allow(@searcher).to receive(:ca?).and_return(true)
+          fh = mock 'filehandle'
+          fh.stubs :print
+          Puppet.settings.setting(@setting).expects(:open).with('w:ASCII').yields fh
           @searcher.save(@request)
         end
       end
@@ -253,7 +234,7 @@ describe Puppet::Indirector::SslFile do
     describe "when destroying certificates" do
       describe "that do not exist" do
         before do
-          expect(Puppet::FileSystem).to receive(:exist?).with(Puppet::FileSystem.pathname(@certpath)).and_return(false)
+          Puppet::FileSystem.expects(:exist?).with(Puppet::FileSystem.pathname(@certpath)).returns false
         end
 
         it "should return false" do
@@ -264,49 +245,49 @@ describe Puppet::Indirector::SslFile do
       describe "that exist" do
         it "should unlink the certificate file" do
           path = Puppet::FileSystem.pathname(@certpath)
-          expect(Puppet::FileSystem).to receive(:exist?).with(path).and_return(true)
-          expect(Puppet::FileSystem).to receive(:unlink).with(path)
+          Puppet::FileSystem.expects(:exist?).with(path).returns true
+          Puppet::FileSystem.expects(:unlink).with(path)
           @searcher.destroy(@request)
         end
 
         it "should log that is removing the file" do
-          allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-          allow(Puppet::FileSystem).to receive(:unlink)
-          expect(Puppet).to receive(:notice)
+          Puppet::FileSystem.stubs(:exist?).returns true
+          Puppet::FileSystem.stubs(:unlink)
+          Puppet.expects(:notice)
           @searcher.destroy(@request)
         end
       end
     end
 
     describe "when searching for certificates" do
-      let(:one) { double('one') }
-      let(:two) { double('two') }
+      let(:one) { stub 'one' }
+      let(:two) { stub 'two' }
       let(:one_path) { File.join(@path, 'one.pem') }
       let(:two_path) { File.join(@path, 'two.pem') }
-      let(:model) { double('model') }
+      let(:model) { mock 'model' }
 
       before :each do
-        allow(@file_class).to receive(:model).and_return(model)
+        terminus_class.stubs(:model).returns model
       end
 
       it "should return a certificate instance for all files that exist" do
-        expect(Dir).to receive(:entries).with(@path).and_return(%w{. .. one.pem two.pem})
+        Dir.expects(:entries).with(@path).returns(%w{. .. one.pem two.pem})
 
-        expect(model).to receive(:new).with("one").and_return(one)
-        expect(one).to receive(:read).with(one_path)
-        expect(model).to receive(:new).with("two").and_return(two)
-        expect(two).to receive(:read).with(two_path)
+        model.expects(:new).with("one").returns one
+        one.expects(:read).with(one_path)
+        model.expects(:new).with("two").returns two
+        two.expects(:read).with(two_path)
 
         expect(@searcher.search(@request)).to eq([one, two])
       end
 
       it "should raise an exception if any file is unreadable" do
-        expect(Dir).to receive(:entries).with(@path).and_return(%w{. .. one.pem two.pem})
+        Dir.expects(:entries).with(@path).returns(%w{. .. one.pem two.pem})
 
-        expect(model).to receive(:new).with("one").and_return(one)
-        expect(one).to receive(:read).with(one_path)
-        expect(model).to receive(:new).with("two").and_return(two)
-        expect(two).to receive(:read).and_raise(Errno::EACCES)
+        model.expects(:new).with("one").returns(one)
+        one.expects(:read).with(one_path)
+        model.expects(:new).with("two").returns(two)
+        two.expects(:read).raises(Errno::EACCES)
 
         expect {
           @searcher.search(@request)
@@ -314,9 +295,9 @@ describe Puppet::Indirector::SslFile do
       end
 
       it "should skip any files that do not match /\.pem$/" do
-        expect(Dir).to receive(:entries).with(@path).and_return(%w{. .. one two.notpem})
+        Dir.expects(:entries).with(@path).returns(%w{. .. one two.notpem})
 
-        expect(model).not_to receive(:new)
+        model.expects(:new).never
 
         expect(@searcher.search(@request)).to eq([])
       end

data/spec/unit/indirector/status/local_spec.rb

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

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

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

data/spec/unit/indirector/store_configs_spec.rb

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

data/spec/unit/indirector/terminus_spec.rb

@@ -1,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 require 'puppet/defaults'
 require 'puppet/indirector'
@@ -20,7 +21,7 @@ describe Puppet::Indirector::Terminus do
 
   after :all do
     # Remove the class, unlinking it from the rest of the system.
-    Puppet.send(:remove_const, :AbstractConcept) if Puppet.const_defined?(:AbstractConcept)
+    Puppet.send(:remove_const, :AbstractConcept)
   end
 
   let :terminus_class do Puppet::AbstractConcept::Freedom end
@@ -93,13 +94,13 @@ describe Puppet::Indirector::Terminus do
     end
 
     it "should provide a method for returning terminus classes by name and type" do
-      terminus = double('terminus_type', :name => :abstract, :indirection_name => :whatever)
+      terminus = stub 'terminus_type', :name => :abstract, :indirection_name => :whatever
       Puppet::Indirector::Terminus.register_terminus_class(terminus)
       expect(Puppet::Indirector::Terminus.terminus_class(:whatever, :abstract)).to equal(terminus)
     end
 
     it "should set up autoloading for any terminus class types requested" do
-      expect(Puppet::Indirector::Terminus).to receive(:instance_load).with(:test2, "puppet/indirector/test2")
+      Puppet::Indirector::Terminus.expects(:instance_load).with(:test2, "puppet/indirector/test2")
       Puppet::Indirector::Terminus.terminus_class(:test2, :whatever)
     end
 
@@ -107,12 +108,12 @@ describe Puppet::Indirector::Terminus do
       # Set up instance loading; it would normally happen automatically
       Puppet::Indirector::Terminus.instance_load :test1, "puppet/indirector/test1"
 
-      expect(Puppet::Indirector::Terminus.instance_loader(:test1)).to receive(:load).with(:yay)
+      Puppet::Indirector::Terminus.instance_loader(:test1).expects(:load).with(:yay, anything)
       Puppet::Indirector::Terminus.terminus_class(:test1, :yay)
     end
 
     it "should fail when no indirection can be found" do
-      expect(Puppet::Indirector::Indirection).to receive(:instance).with(:abstract_concept).and_return(nil)
+      Puppet::Indirector::Indirection.expects(:instance).with(:abstract_concept).returns(nil)
       expect {
         class Puppet::AbstractConcept::Physics < Puppet::Indirector::Code
         end
@@ -120,9 +121,8 @@ describe Puppet::Indirector::Terminus do
     end
 
     it "should register the terminus class with the terminus base class" do
-      expect(Puppet::Indirector::Terminus).to receive(:register_terminus_class) do |type|
-        expect(type.indirection_name).to eq(:abstract_concept)
-        expect(type.name).to eq(:intellect)
+      Puppet::Indirector::Terminus.expects(:register_terminus_class).with do |type|
+        type.indirection_name == :abstract_concept and type.name == :intellect
       end
 
       begin
@@ -136,13 +136,13 @@ describe Puppet::Indirector::Terminus do
 
   describe "when parsing class constants for indirection and terminus names" do
     before :each do
-      allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
+      Puppet::Indirector::Terminus.stubs(:register_terminus_class)
     end
 
     let :subclass do
-      subclass = double('subclass')
-      allow(subclass).to receive(:to_s).and_return("TestInd::OneTwo")
-      allow(subclass).to receive(:mark_as_abstract_terminus)
+      subclass = mock 'subclass'
+      subclass.stubs(:to_s).returns("TestInd::OneTwo")
+      subclass.stubs(:mark_as_abstract_terminus)
       subclass
     end
 
@@ -153,51 +153,49 @@ describe Puppet::Indirector::Terminus do
     end
 
     it "should use the last term in the constant for the terminus class name" do
-      expect(subclass).to receive(:name=).with(:one_two)
-      allow(subclass).to receive(:indirection=)
+      subclass.expects(:name=).with(:one_two)
+      subclass.stubs(:indirection=)
       Puppet::Indirector::Terminus.inherited(subclass)
     end
 
     it "should convert the terminus name to a downcased symbol" do
-      expect(subclass).to receive(:name=).with(:one_two)
-      allow(subclass).to receive(:indirection=)
+      subclass.expects(:name=).with(:one_two)
+      subclass.stubs(:indirection=)
       Puppet::Indirector::Terminus.inherited(subclass)
     end
 
     it "should use the second to last term in the constant for the indirection name" do
-      expect(subclass).to receive(:indirection=).with(:test_ind)
-      allow(subclass).to receive(:name=)
-      allow(subclass).to receive(:terminus_type=)
+      subclass.expects(:indirection=).with(:test_ind)
+      subclass.stubs(:name=)
+      subclass.stubs(:terminus_type=)
       Puppet::Indirector::Memory.inherited(subclass)
     end
 
     it "should convert the indirection name to a downcased symbol" do
-      expect(subclass).to receive(:indirection=).with(:test_ind)
-      allow(subclass).to receive(:name=)
-      allow(subclass).to receive(:terminus_type=)
+      subclass.expects(:indirection=).with(:test_ind)
+      subclass.stubs(:name=)
+      subclass.stubs(:terminus_type=)
       Puppet::Indirector::Memory.inherited(subclass)
     end
 
     it "should convert camel case to lower case with underscores as word separators" do
-      expect(subclass).to receive(:name=).with(:one_two)
-      allow(subclass).to receive(:indirection=)
+      subclass.expects(:name=).with(:one_two)
+      subclass.stubs(:indirection=)
 
       Puppet::Indirector::Terminus.inherited(subclass)
     end
   end
 
   describe "when creating terminus class types" do
-    before(:each) do
-      allow(Puppet::Indirector::Terminus).to receive(:register_terminus_class)
-    end
+    before :each do
+      Puppet::Indirector::Terminus.stubs(:register_terminus_class)
 
-    before :all do
       class Puppet::Indirector::Terminus::TestTerminusType < Puppet::Indirector::Terminus
       end
     end
 
-    after :all do
-      Puppet::Indirector::Terminus.send(:remove_const, :TestTerminusType) if Puppet::Indirector::Terminus.const_defined?(:TestTerminusType)
+    after :each do
+      Puppet::Indirector::Terminus.send(:remove_const, :TestTerminusType)
     end
 
     let :subclass do
@@ -219,7 +217,7 @@ describe Puppet::Indirector::Terminus do
 
   describe "when listing terminus classes" do
     it "should list the terminus files available to load" do
-      allow_any_instance_of(Puppet::Util::Autoload).to receive(:files_to_load).and_return(["/foo/bar/baz", "/max/runs/marathon"])
+      Puppet::Util::Autoload.any_instance.stubs(:files_to_load).returns ["/foo/bar/baz", "/max/runs/marathon"]
       expect(Puppet::Indirector::Terminus.terminus_classes('my_stuff')).to eq([:baz, :marathon])
     end
   end
@@ -243,7 +241,7 @@ describe Puppet::Indirector::Terminus do
     end
 
     describe "`instance` is not an instance of the model class" do
-      let(:instance) { double("instance") }
+      let(:instance) { mock "instance" }
 
       it "raises an error" do
         expect {