puppet 5.5.22-universal-darwin → 6.0.0-universal-darwin

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

@@ -1,3 +1,4 @@
+#! /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,3 +1,4 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_bucket_file/selector'
@@ -8,17 +9,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 = double('request', :protocol => 'https')
+        request = stub 'request', :protocol => 'https'
 
-        expect_any_instance_of(Puppet::FileBucketFile::Rest).to receive(method).with(request)
+        Puppet::FileBucketFile::Rest.any_instance.expects(method).with(request)
 
         subject.send(method, request)
       end
 
       it "should proxy to file terminus for other requests" do
-        request = double('request', :protocol => 'file')
+        request = stub 'request', :protocol => 'file'
 
-        expect_any_instance_of(Puppet::FileBucketFile::File).to receive(method).with(request)
+        Puppet::FileBucketFile::File.any_instance.expects(method).with(request)
 
         subject.send(method, request)
       end

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

data/spec/unit/indirector/file_server_spec.rb

@@ -1,302 +1,302 @@
+#! /usr/bin/env ruby
 require 'spec_helper'
 
 require 'puppet/indirector/file_server'
 require 'puppet/file_serving/configuration'
 
 describe Puppet::Indirector::FileServer do
-  before(:each) 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)
-
-    module Testing; end
-
-    # The Indirector does a lot of class-level caching of things, and indirections register themselves
-    # whenever they're created (at include time), which makes working with them in tests _very_ annoying.
-    # We're effectively undefining the test class if it exists from a previous test so that we can
-    # re-register the new one as any mocks/stubs that existed on the old one from a previous test will no
-    # longer be valid, and will cause rspec-mocks to (rightfully) blow up.
-    Testing.send(:remove_const, :MyFileServer) if Testing.constants.include?(:MyFileServer)
-
-    @file_server_class = class Testing::MyFileServer < Puppet::Indirector::FileServer
-      self
+  before :all do
+    class Puppet::FileTestModel
+      extend Puppet::Indirector
+      indirects :file_test_model
+      attr_accessor :path
+      def initialize(path = '/', options = {})
+        @path = path
+        @options = options
+      end
     end
 
-    @file_server = @file_server_class.new
+    class Puppet::FileTestModel::FileServer < Puppet::Indirector::FileServer
+    end
+
+    Puppet::FileTestModel.indirection.terminus_class = :file_server
+  end
 
-    @uri = "puppet://host/my/local/file"
-    @configuration = double('configuration')
-    allow(Puppet::FileServing::Configuration).to receive(:configuration).and_return(@configuration)
+  let(:path) { File.expand_path('/my/local') }
+  let(:terminus) { Puppet::FileTestModel.indirection.terminus(:file_server) }
+  let(:indirection) { Puppet::FileTestModel.indirection }
+  let(:model) { Puppet::FileTestModel }
+  let(:uri) { "puppet://host/my/local/file" }
+  let(:configuration) { mock 'configuration' }
+
+  after(:all) do
+    Puppet::FileTestModel.indirection.delete
+    Puppet.send(:remove_const, :FileTestModel)
+  end
 
-    @request = Puppet::Indirector::Request.new(:myind, :mymethod, @uri, :environment => "myenv")
+  before(:each)do
+    Puppet::FileServing::Configuration.stubs(:configuration).returns(configuration)
   end
 
   describe "when finding files" do
-    before do
-      @mount = double('mount', :find => nil)
-      @instance = double('instance', :links= => nil, :collect => nil)
-    end
+    let(:mount) { stub('mount', find: nil) }
+    let(:instance) { stub('instance', :links= => nil, :collect => nil) }
 
     it "should use the configuration to find the mount and relative path" do
-      expect(@configuration).to receive(:split_path).with(@request)
+      configuration.expects(:split_path).with do |args|
+        args.uri == uri
+      end
 
-      @file_server.find(@request)
+      indirection.find(uri)
     end
 
     it "should return nil if it cannot find the mount" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([nil, nil])
+      configuration.expects(:split_path).returns(nil, nil)
 
-      expect(@file_server.find(@request)).to be_nil
+      expect(indirection.find(uri)).to be_nil
     end
 
     it "should use the mount to find the full path" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:find).with("rel/path", anything)
+      mount.expects(:find).with { |key, request| key == "rel/path" }
 
-      @file_server.find(@request)
+      indirection.find(uri)
     end
 
     it "should pass the request when finding a file" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:find).with(anything, @request)
+      mount.expects(:find).with { |_, request| request.uri == uri }
 
-      @file_server.find(@request)
+      indirection.find(uri)
     end
 
     it "should return nil if it cannot find a full path" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:find).with("rel/path", anything).and_return(nil)
+      mount.expects(:find).with { |key, request| key == "rel/path" }.returns nil
 
-      expect(@file_server.find(@request)).to be_nil
+      expect(indirection.find(uri)).to be_nil
     end
 
     it "should create an instance with the found path" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:find).with("rel/path", anything).and_return("/my/file")
+      mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
-      expect(@model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(@instance)
+      model.expects(:new).with("/my/file", {:relative_path => nil}).returns instance
 
-      expect(@file_server.find(@request)).to equal(@instance)
+      expect(indirection.find(uri)).to equal(instance)
     end
 
     it "should set 'links' on the instance if it is set in the request options" do
-      @request.options[:links] = true
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:find).with("rel/path", anything).and_return("/my/file")
+      mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
-      expect(@model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(@instance)
+      model.expects(:new).with("/my/file", {:relative_path => nil}).returns instance
 
-      expect(@instance).to receive(:links=).with(true)
+      instance.expects(:links=).with(true)
 
-      expect(@file_server.find(@request)).to equal(@instance)
+      expect(indirection.find(uri, links: true)).to equal(instance)
     end
 
     it "should collect the instance" do
-      @request.options[:links] = true
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:find).with("rel/path", anything).and_return("/my/file")
+      mount.expects(:find).with { |key, request| key == "rel/path" }.returns "/my/file"
 
-      expect(@model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(@instance)
+      model.expects(:new).with("/my/file", {:relative_path => nil}).returns instance
 
-      expect(@instance).to receive(:collect)
+      instance.expects(:collect)
 
-      expect(@file_server.find(@request)).to equal(@instance)
+      expect(indirection.find(uri, links: true)).to equal(instance)
     end
   end
 
   describe "when searching for instances" do
-    before do
-      @mount = double('mount', :search => nil)
-      @instance = double('instance', :links= => nil, :collect => nil)
-    end
+    let(:mount) { stub('mount', find: nil) }
 
     it "should use the configuration to search the mount and relative path" do
-      expect(@configuration).to receive(:split_path).with(@request)
+      configuration.expects(:split_path).with do |args|
+        args.uri == uri
+      end
 
-      @file_server.search(@request)
+      indirection.search(uri)
     end
 
     it "should return nil if it cannot search the mount" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([nil, nil])
+      configuration.expects(:split_path).returns(nil, nil)
 
-      expect(@file_server.search(@request)).to be_nil
+      expect(indirection.search(uri)).to be_nil
     end
 
     it "should use the mount to search for the full paths" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:search).with("rel/path", anything)
+      mount.expects(:search).with { |key, request| key == "rel/path" }
 
-      @file_server.search(@request)
+      indirection.search(uri)
     end
 
     it "should pass the request" do
-      allow(@configuration).to receive(:split_path).and_return([@mount, "rel/path"])
+      configuration.stubs(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:search).with(anything, @request)
+      mount.expects(:search).with { |_, request| request.uri == uri }
 
-      @file_server.search(@request)
+      indirection.search(uri)
     end
 
     it "should return nil if searching does not find any full paths" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:search).with("rel/path", anything).and_return(nil)
+      mount.expects(:search).with { |key, request| key == "rel/path" }.returns nil
 
-      expect(@file_server.search(@request)).to be_nil
+      expect(indirection.search(uri)).to be_nil
     end
 
     it "should create a fileset with each returned path and merge them" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:search).with("rel/path", anything).and_return(%w{/one /two})
+      mount.expects(:search).with { |key, request| key == "rel/path" }.returns %w{/one /two}
 
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
 
-      one = double('fileset_one')
-      expect(Puppet::FileServing::Fileset).to receive(:new).with("/one", @request).and_return(one)
-      two = double('fileset_two')
-      expect(Puppet::FileServing::Fileset).to receive(:new).with("/two", @request).and_return(two)
+      one = mock 'fileset_one'
+      Puppet::FileServing::Fileset.expects(:new).with("/one", anything).returns(one)
+      two = mock 'fileset_two'
+      Puppet::FileServing::Fileset.expects(:new).with("/two", anything).returns(two)
 
-      expect(Puppet::FileServing::Fileset).to receive(:merge).with(one, two).and_return([])
+      Puppet::FileServing::Fileset.expects(:merge).with(one, two).returns []
 
-      @file_server.search(@request)
+      indirection.search(uri)
     end
 
     it "should create an instance with each path resulting from the merger of the filesets" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:search).with("rel/path", anything).and_return([])
+      mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
 
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one", "two" => "/two")
+      Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one", "two" => "/two")
 
-      one = double('one', :collect => nil)
-      expect(@model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
+      one = stub 'one', :collect => nil
+      model.expects(:new).with("/one", :relative_path => "one").returns one
 
-      two = double('two', :collect => nil)
-      expect(@model).to receive(:new).with("/two", :relative_path => "two").and_return(two)
+      two = stub 'two', :collect => nil
+      model.expects(:new).with("/two", :relative_path => "two").returns two
 
       # order can't be guaranteed
-      result = @file_server.search(@request)
+      result = indirection.search(uri)
       expect(result).to be_include(one)
       expect(result).to be_include(two)
       expect(result.length).to eq(2)
     end
 
     it "should set 'links' on the instances if it is set in the request options" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
-
-      expect(@mount).to receive(:search).with("rel/path", anything).and_return([])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
+      Puppet::FileSystem.stubs(:exist?).returns true
 
-      one = double('one', :collect => nil)
-      expect(@model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
-      expect(one).to receive(:links=).with(true)
+      Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
-      @request.options[:links] = true
+      one = stub 'one', :collect => nil
+      model.expects(:new).with("/one", :relative_path => "one").returns one
+      one.expects(:links=).with true
 
-      @file_server.search(@request)
+      indirection.search(uri, links: true)
     end
 
     it "should set 'checksum_type' on the instances if it is set in the request options" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:search).with("rel/path", anything).and_return([])
+      mount.expects(:search).with { |key, request| key == "rel/path" }.returns []
 
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
 
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
+      Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
-      one = double('one', :collect => nil)
-      expect(@model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
+      one = stub 'one', :collect => nil
+      model.expects(:new).with("/one", :relative_path => "one").returns one
 
-      expect(one).to receive(:checksum_type=).with(:checksum)
-      @request.options[:checksum_type] = :checksum
+      one.expects(:checksum_type=).with :checksum
 
-      @file_server.search(@request)
+      indirection.search(uri, checksum_type: :checksum)
     end
 
     it "should collect the instances" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
+      configuration.expects(:split_path).returns([mount, "rel/path"])
 
-      expect(@mount).to receive(:search).with("rel/path", anything).and_return([])
+      mount.expects(:search).with { |key, options| key == "rel/path" }.returns []
 
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
+      Puppet::FileSystem.stubs(:exist?).returns true
 
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
+      Puppet::FileServing::Fileset.expects(:merge).returns("one" => "/one")
 
-      one = double('one')
-      expect(@model).to receive(:new).with("/one", :relative_path => "one").and_return(one)
-      expect(one).to receive(:collect)
+      one = mock 'one'
+      model.expects(:new).with("/one", :relative_path => "one").returns one
+      one.expects(:collect)
 
-      @file_server.search(@request)
+      indirection.search(uri)
     end
   end
 
   describe "when checking authorization" do
-    before do
-      @request.method = :find
-
-      @mount = double('mount')
-      allow(@configuration).to receive(:split_path).with(@request).and_return([@mount, "rel/path"])
-      allow(@request).to receive(:node).and_return("mynode")
-      allow(@request).to receive(:ip).and_return("myip")
-      allow(@mount).to receive(:name).and_return("myname")
-      allow(@mount).to receive(:allowed?).with("mynode", "myip").and_return("something")
-      allow(@mount).to receive(:empty?)
-      allow(@mount).to receive(:globalallow?)
+    let(:mount) { stub('mount') }
+    let(:request) { Puppet::Indirector::Request.new(:myind, :mymethod, uri, :environment => "myenv") }
+
+    before(:each) do
+      request.method = :find
+
+      configuration.stubs(:split_path).returns([mount, "rel/path"])
+      request.stubs(:node).returns("mynode")
+      request.stubs(:ip).returns("myip")
+      mount.stubs(:name).returns "myname"
+      mount.stubs(:allowed?).with("mynode", "myip").returns "something"
     end
 
     it "should return false when destroying" do
-      @request.method = :destroy
-      expect(@file_server).not_to be_authorized(@request)
+      request.method = :destroy
+      expect(terminus).not_to be_authorized(request)
     end
 
     it "should return false when saving" do
-      @request.method = :save
-      expect(@file_server).not_to be_authorized(@request)
+      request.method = :save
+      expect(terminus).not_to be_authorized(request)
     end
 
     it "should use the configuration to find the mount and relative path" do
-      expect(@configuration).to receive(:split_path).with(@request)
+      configuration.expects(:split_path).with(request)
 
-      @file_server.authorized?(@request)
+      terminus.authorized?(request)
     end
 
     it "should return false if it cannot find the mount" do
-      expect(@configuration).to receive(:split_path).with(@request).and_return([nil, nil])
+      configuration.expects(:split_path).returns(nil, nil)
 
-      expect(@file_server).not_to be_authorized(@request)
+      expect(terminus).not_to be_authorized(request)
     end
 
     it "should return true when no auth directives are defined for the mount point" do
-      allow(@mount).to receive(:empty?).and_return(true)
-      allow(@mount).to receive(:globalallow?).and_return(nil)
-      expect(@file_server).to be_authorized(@request)
+      mount.stubs(:empty?).returns true
+      mount.stubs(:globalallow?).returns nil
+      expect(terminus).to be_authorized(request)
     end
 
     it "should return true when a global allow directive is defined for the mount point" do
-      allow(@mount).to receive(:empty?).and_return(false)
-      allow(@mount).to receive(:globalallow?).and_return(true)
-      expect(@file_server).to be_authorized(@request)
+      mount.stubs(:empty?).returns false
+      mount.stubs(:globalallow?).returns true
+      expect(terminus).to be_authorized(request)
     end
 
     it "should return false when a non-global allow directive is defined for the mount point" do
-      allow(@mount).to receive(:empty?).and_return(false)
-      allow(@mount).to receive(:globalallow?).and_return(false)
-      expect(@file_server).not_to be_authorized(@request)
+      mount.stubs(:empty?).returns false
+      mount.stubs(:globalallow?).returns false
+      expect(terminus).not_to be_authorized(request)
     end
   end
 end