puppet 7.28.0-x64-mingw32 → 7.29.1-x64-mingw32

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

@@ -1,13 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/file_metadata/file_server'
-
-describe Puppet::Indirector::FileMetadata::FileServer do
-  it "should be registered with the file_metadata indirection" do
-    expect(Puppet::Indirector::Terminus.terminus_class(:file_metadata, :file_server)).to equal(Puppet::Indirector::FileMetadata::FileServer)
-  end
-
-  it "should be a subclass of the FileServer terminus" do
-    expect(Puppet::Indirector::FileMetadata::FileServer.superclass).to equal(Puppet::Indirector::FileServer)
-  end
-end

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

@@ -1,57 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/file_metadata/file'
-
-describe Puppet::Indirector::FileMetadata::File do
-  it "should be registered with the file_metadata indirection" do
-    expect(Puppet::Indirector::Terminus.terminus_class(:file_metadata, :file)).to equal(Puppet::Indirector::FileMetadata::File)
-  end
-
-  it "should be a subclass of the DirectFileServer terminus" do
-    expect(Puppet::Indirector::FileMetadata::File.superclass).to equal(Puppet::Indirector::DirectFileServer)
-  end
-
-  describe "when creating the instance for a single found file" do
-    before 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)
-
-      @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)
-
-      expect(Puppet::FileServing::Metadata).to receive(:new).and_return(@data)
-      expect(@metadata.find(@request)).to eq(@data)
-    end
-  end
-
-  describe "when searching for multiple files" do
-    before do
-      @metadata = Puppet::Indirector::FileMetadata::File.new
-      @path = File.expand_path('/my/local')
-      @uri = Puppet::Util.path_to_uri(@path).to_s
-
-      @request = Puppet::Indirector::Request.new(:file_metadata, :find, @uri, nil)
-    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]])
-
-      one = double("one", :collect => nil)
-      expect(Puppet::FileServing::Metadata).to receive(:new).with(@path, {:relative_path => "one"}).and_return(one)
-
-      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
-  end
-end

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

@@ -1,194 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/file_metadata'
-require 'puppet/indirector/file_metadata/http'
-
-describe Puppet::Indirector::FileMetadata::Http do
-  DEFAULT_HEADERS = {
-    "Cache-Control" => "private, max-age=0",
-    "Connection" => "close",
-    "Content-Encoding" => "gzip",
-    "Content-Type" => "text/html; charset=ISO-8859-1",
-    "Date" => "Fri, 01 May 2020 17:16:00 GMT",
-    "Expires" => "-1",
-    "Server" => "gws"
-  }.freeze
-
-  let(:certname) { 'ziggy' }
-  # The model is Puppet:FileServing::Metadata
-  let(:model) { described_class.model }
-  # The http terminus creates instances of HttpMetadata which subclass Metadata
-  let(:metadata) { Puppet::FileServing::HttpMetadata.new(key) }
-  let(:key) { "https://example.com/path/to/file" }
-  # Digest::MD5.base64digest("") => "1B2M2Y8AsgTpgAmY7PhCfg=="
-  let(:content_md5) { {"Content-MD5" => "1B2M2Y8AsgTpgAmY7PhCfg=="} }
-  let(:last_modified) { {"Last-Modified" => "Wed, 01 Jan 2020 08:00:00 GMT"} }
-
-  before :each do
-    described_class.indirection.terminus_class = :http
-  end
-
-  context "when finding" do
-    it "returns http file metadata" do
-      stub_request(:head, key)
-        .to_return(status: 200, headers: DEFAULT_HEADERS)
-
-      result = model.indirection.find(key)
-      expect(result.ftype).to eq('file')
-      expect(result.path).to eq('/dev/null')
-      expect(result.relative_path).to be_nil
-      expect(result.destination).to be_nil
-      expect(result.checksum).to match(%r{mtime})
-      expect(result.owner).to be_nil
-      expect(result.group).to be_nil
-      expect(result.mode).to be_nil
-    end
-
-    it "reports an md5 checksum if present in the response" do
-      stub_request(:head, key)
-        .to_return(status: 200, headers: DEFAULT_HEADERS.merge(content_md5))
-
-      result = model.indirection.find(key)
-      expect(result.checksum_type).to eq(:md5)
-      expect(result.checksum).to eq("{md5}d41d8cd98f00b204e9800998ecf8427e")
-    end
-
-    it "reports an mtime checksum if present in the response" do
-      stub_request(:head, key)
-        .to_return(status: 200, headers: DEFAULT_HEADERS.merge(last_modified))
-
-      result = model.indirection.find(key)
-      expect(result.checksum_type).to eq(:mtime)
-      expect(result.checksum).to eq("{mtime}2020-01-01 08:00:00 UTC")
-    end
-
-    it "prefers md5" do
-      stub_request(:head, key)
-        .to_return(status: 200, headers: DEFAULT_HEADERS.merge(content_md5).merge(last_modified))
-
-      result = model.indirection.find(key)
-      expect(result.checksum_type).to eq(:md5)
-      expect(result.checksum).to eq("{md5}d41d8cd98f00b204e9800998ecf8427e")
-    end
-
-    it "prefers mtime when explicitly requested" do
-      stub_request(:head, key)
-        .to_return(status: 200, headers: DEFAULT_HEADERS.merge(content_md5).merge(last_modified))
-
-      result = model.indirection.find(key, checksum_type: :mtime)
-      expect(result.checksum_type).to eq(:mtime)
-      expect(result.checksum).to eq("{mtime}2020-01-01 08:00:00 UTC")
-    end
-
-    it "leniently parses base64" do
-      # Content-MD5 header is missing '==' padding
-      stub_request(:head, key)
-        .to_return(status: 200, headers: DEFAULT_HEADERS.merge("Content-MD5" => "1B2M2Y8AsgTpgAmY7PhCfg"))
-
-      result = model.indirection.find(key)
-      expect(result.checksum_type).to eq(:md5)
-      expect(result.checksum).to eq("{md5}d41d8cd98f00b204e9800998ecf8427e")
-    end
-
-    it "URL encodes special characters" do
-      pending("HTTP terminus doesn't encode the URI before parsing")
-
-      stub_request(:head, %r{/path%20to%20file})
-
-      model.indirection.find('https://example.com/path to file')
-    end
-
-    it "sends query parameters" do
-      stub_request(:head, key).with(query: {'a' => 'b'})
-
-      model.indirection.find("#{key}?a=b")
-    end
-
-    it "returns nil if the content doesn't exist" do
-      stub_request(:head, key).to_return(status: 404)
-
-      expect(model.indirection.find(key)).to be_nil
-    end
-
-    it "returns nil if fail_on_404" do
-      stub_request(:head, key).to_return(status: 404)
-
-      expect(model.indirection.find(key, fail_on_404: true)).to be_nil
-    end
-
-    it "returns nil on HTTP 500" do
-      stub_request(:head, key).to_return(status: 500)
-
-      # this is kind of strange, but it does allow puppet to try
-      # multiple `source => ["URL1", "URL2"]` and use the first
-      # one based on sourceselect
-      expect(model.indirection.find(key)).to be_nil
-    end
-
-    it "accepts all content types" do
-      stub_request(:head, key).with(headers: {'Accept' => '*/*'})
-
-      model.indirection.find(key)
-    end
-
-    it "sets puppet user-agent" do
-      stub_request(:head, key).with(headers: {'User-Agent' => Puppet[:http_user_agent]})
-
-      model.indirection.find(key)
-    end
-
-    it "tries to persist the connection" do
-      # HTTP/1.1 defaults to persistent connections, so check for
-      # the header's absence
-      stub_request(:head, key).with do |request|
-        expect(request.headers).to_not include('Connection')
-      end
-
-      model.indirection.find(key)
-    end
-
-    it "follows redirects" do
-      new_url = "https://example.com/different/path"
-      redirect = { status: 200, headers: { 'Location' => new_url }, body: ""}
-      stub_request(:head, key).to_return(redirect)
-      stub_request(:head, new_url)
-
-      model.indirection.find(key)
-    end
-
-    it "falls back to partial GET if HEAD is not allowed" do
-      stub_request(:head, key)
-        .to_return(status: 405)
-      stub_request(:get, key)
-        .to_return(status: 200, headers: {'Range' => 'bytes=0-0'})
-
-      model.indirection.find(key)
-    end
-
-    it "falls back to partial GET if HEAD is forbidden" do
-      stub_request(:head, key)
-        .to_return(status: 403)
-      stub_request(:get, key)
-        .to_return(status: 200, headers: {'Range' => 'bytes=0-0'})
-
-      model.indirection.find(key)
-    end
-
-    it "returns nil if the partial GET fails" do
-      stub_request(:head, key)
-        .to_return(status: 403)
-      stub_request(:get, key)
-        .to_return(status: 403)
-
-      expect(model.indirection.find(key)).to be_nil
-    end
-  end
-
-  context "when searching" do
-    it "raises an error" do
-      expect {
-        model.indirection.search(key)
-      }.to raise_error(Puppet::Error, 'cannot lookup multiple files')
-    end
-  end
-end

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

@@ -1,116 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/file_metadata'
-require 'puppet/indirector/file_metadata/rest'
-
-describe Puppet::Indirector::FileMetadata::Rest do
-  let(:certname) { 'ziggy' }
-  let(:formatter) { Puppet::Network::FormatHandler.format(:json) }
-  let(:model) { described_class.model }
-
-  before :each do
-    described_class.indirection.terminus_class = :rest
-  end
-
-  def metadata_response(metadata)
-    { body: formatter.render(metadata), headers: {'Content-Type' => formatter.mime } }
-  end
-
-  context "when finding" do
-    let(:uri) { %r{/puppet/v3/file_metadata/:mount/path/to/file} }
-    let(:key) { "puppet:///:mount/path/to/file" }
-    let(:metadata) { model.new('/path/to/file') }
-
-    it "returns file metadata" do
-      stub_request(:get, uri)
-        .to_return(status: 200, **metadata_response(metadata))
-
-      result = model.indirection.find(key)
-      expect(result.path).to eq('/path/to/file')
-    end
-
-    it "URL encodes special characters" do
-      stub_request(:get, %r{/puppet/v3/file_metadata/:mount/path%20to%20file})
-        .to_return(status: 200, **metadata_response(metadata))
-
-      model.indirection.find('puppet:///:mount/path to file')
-    end
-
-    it "returns nil if the content doesn't exist" do
-      stub_request(:get, uri).to_return(status: 404)
-
-      expect(model.indirection.find(key)).to be_nil
-    end
-
-    it "raises if fail_on_404 is true" do
-      stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json'}, body: "{}")
-
-      expect {
-        model.indirection.find(key, fail_on_404: true)
-      }.to raise_error(Puppet::Error, %r{Find /puppet/v3/file_metadata/:mount/path/to/file resulted in 404 with the message: {}})
-    end
-
-    it "raises an error on HTTP 500" do
-      stub_request(:get, uri).to_return(status: 500, headers: { 'Content-Type' => 'application/json'}, body: "{}")
-
-      expect {
-        model.indirection.find(key)
-      }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
-    end
-
-    it "connects to a specific host" do
-      stub_request(:get, %r{https://example.com:8140/puppet/v3/file_metadata/:mount/path/to/file})
-        .to_return(status: 200, **metadata_response(metadata))
-
-      model.indirection.find("puppet://example.com:8140/:mount/path/to/file")
-    end
-  end
-
-  context "when searching" do
-    let(:uri) { %r{/puppet/v3/file_metadatas/:mount/path/to/dir} }
-    let(:key) { "puppet:///:mount/path/to/dir" }
-    let(:metadatas) { [model.new('/path/to/dir')] }
-
-    it "returns an array of file metadata" do
-      stub_request(:get, uri)
-        .to_return(status: 200, **metadata_response(metadatas))
-
-      result = model.indirection.search(key)
-      expect(result.first.path).to eq('/path/to/dir')
-    end
-
-    it "URL encodes special characters" do
-      stub_request(:get, %r{/puppet/v3/file_metadatas/:mount/path%20to%20dir})
-        .to_return(status: 200, **metadata_response(metadatas))
-
-      model.indirection.search('puppet:///:mount/path to dir')
-    end
-
-    it "returns an empty array if the metadata doesn't exist" do
-      stub_request(:get, uri).to_return(status: 404)
-
-      expect(model.indirection.search(key)).to eq([])
-    end
-
-    it "returns an empty array if the metadata doesn't exist and fail_on_404 is true" do
-      stub_request(:get, uri).to_return(status: 404, headers: { 'Content-Type' => 'application/json'}, body: "{}")
-
-      expect(model.indirection.search(key, fail_on_404: true)).to eq([])
-    end
-
-    it "raises an error on HTTP 500" do
-      stub_request(:get, uri).to_return(status: 500, headers: { 'Content-Type' => 'application/json'}, body: "{}")
-
-      expect {
-        model.indirection.search(key)
-      }.to raise_error(Net::HTTPError, %r{Error 500 on SERVER: })
-    end
-
-    it "connects to a specific host" do
-      stub_request(:get, %r{https://example.com:8140/puppet/v3/file_metadatas/:mount/path/to/dir})
-        .to_return(status: 200, **metadata_response(metadatas))
-
-      model.indirection.search("puppet://example.com:8140/:mount/path/to/dir")
-    end
-  end
-end

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

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/file_metadata/selector'
-
-describe Puppet::Indirector::FileMetadata::Selector do
-  include PuppetSpec::Files
-
-  it_should_behave_like "Puppet::FileServing::Files", :file_metadata
-end
-

data/spec/unit/indirector/file_server_spec.rb

@@ -1,288 +0,0 @@
-require 'spec_helper'
-
-require 'puppet/indirector/file_server'
-require 'puppet/file_serving/configuration'
-
-describe Puppet::Indirector::FileServer do
-  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
-
-    class Puppet::FileTestModel::FileServer < Puppet::Indirector::FileServer
-    end
-
-    Puppet::FileTestModel.indirection.terminus_class = :file_server
-  end
-
-  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) { double('configuration') }
-
-  after(:all) do
-    Puppet::FileTestModel.indirection.delete
-    Puppet.send(:remove_const, :FileTestModel)
-  end
-
-  before(:each)do
-    allow(Puppet::FileServing::Configuration).to receive(:configuration).and_return(configuration)
-  end
-
-  describe "when finding files" do
-    let(:mount) { double('mount', find: nil) }
-    let(:instance) { double('instance', :links= => nil, :collect => nil) }
-
-    it "should use the configuration to find the mount and relative path" do
-      expect(configuration).to receive(:split_path) do |args|
-        expect(args.uri).to eq(uri)
-        nil
-      end
-
-      indirection.find(uri)
-    end
-
-    it "should return nil if it cannot find the mount" do
-      expect(configuration).to receive(:split_path).and_return([nil, 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).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:find).with("rel/path", anything)
-
-      indirection.find(uri)
-    end
-
-    it "should pass the request when finding a file" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:find) { |_, request| expect(request.uri).to eq(uri) }.and_return(nil)
-
-      indirection.find(uri)
-    end
-
-    it "should return nil if it cannot find a full path" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:find).with("rel/path", anything)
-
-      expect(indirection.find(uri)).to be_nil
-    end
-
-    it "should create an instance with the found path" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:find).with("rel/path", anything).and_return("/my/file")
-
-      expect(model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(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
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:find).with("rel/path", anything).and_return("/my/file")
-
-      expect(model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(instance)
-
-      expect(instance).to receive(:links=).with(true)
-
-      expect(indirection.find(uri, links: true)).to equal(instance)
-    end
-
-    it "should collect the instance" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:find).with("rel/path", anything).and_return("/my/file")
-
-      expect(model).to receive(:new).with("/my/file", {:relative_path => nil}).and_return(instance)
-
-      expect(instance).to receive(:collect)
-
-      expect(indirection.find(uri, links: true)).to equal(instance)
-    end
-  end
-
-  describe "when searching for instances" do
-    let(:mount) { double('mount', find: nil) }
-
-    it "should use the configuration to search the mount and relative path" do
-      expect(configuration).to receive(:split_path) do |args|
-        expect(args.uri).to eq(uri)
-      end.and_return([nil, nil])
-
-      indirection.search(uri)
-    end
-
-    it "should return nil if it cannot search the mount" do
-      expect(configuration).to receive(:split_path).and_return([nil, 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).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:search).with("rel/path", anything)
-
-      indirection.search(uri)
-    end
-
-    it "should pass the request" do
-      allow(configuration).to receive(:split_path).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:search) { |_, request| expect(request.uri).to eq(uri) }.and_return(nil)
-
-      indirection.search(uri)
-    end
-
-    it "should return nil if searching does not find any full paths" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:search).with("rel/path", anything).and_return(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).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:search).with("rel/path", anything).and_return(%w{/one /two})
-
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-
-      one = double('fileset_one')
-      expect(Puppet::FileServing::Fileset).to receive(:new).with("/one", anything).and_return(one)
-      two = double('fileset_two')
-      expect(Puppet::FileServing::Fileset).to receive(:new).with("/two", anything).and_return(two)
-
-      expect(Puppet::FileServing::Fileset).to receive(:merge).with(one, two).and_return([])
-
-      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).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:search).with("rel/path", anything).and_return([])
-
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one", "two" => "/two")
-
-      one = double('one', :collect => nil)
-      expect(model).to receive(:new).with("/one", {:relative_path => "one"}).and_return(one)
-
-      two = double('two', :collect => nil)
-      expect(model).to receive(:new).with("/two", {:relative_path => "two"}).and_return(two)
-
-      # order can't be guaranteed
-      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).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:search).with("rel/path", anything).and_return([])
-
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
-
-      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)
-
-      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).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:search).with("rel/path", anything).and_return([])
-
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
-
-      one = double('one', :collect => nil)
-      expect(model).to receive(:new).with("/one", {:relative_path => "one"}).and_return(one)
-
-      expect(one).to receive(:checksum_type=).with(:checksum)
-
-      indirection.search(uri, checksum_type: :checksum)
-    end
-
-    it "should collect the instances" do
-      expect(configuration).to receive(:split_path).and_return([mount, "rel/path"])
-
-      expect(mount).to receive(:search).with("rel/path", anything).and_return([])
-
-      allow(Puppet::FileSystem).to receive(:exist?).and_return(true)
-
-      expect(Puppet::FileServing::Fileset).to receive(:merge).and_return("one" => "/one")
-
-      one = double('one')
-      expect(model).to receive(:new).with("/one", {:relative_path => "one"}).and_return(one)
-      expect(one).to receive(:collect)
-
-      indirection.search(uri)
-    end
-  end
-
-  describe "when checking authorization" do
-    let(:mount) { double('mount') }
-    let(:request) { Puppet::Indirector::Request.new(:myind, :mymethod, uri, :environment => "myenv") }
-
-    before(:each) do
-      request.method = :find
-
-      allow(configuration).to receive(:split_path).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")
-    end
-
-    it "should return false when destroying" do
-      request.method = :destroy
-      expect(terminus).not_to be_authorized(request)
-    end
-
-    it "should return false when saving" do
-      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)
-
-      terminus.authorized?(request)
-    end
-
-    it "should return false if it cannot find the mount" do
-      expect(configuration).to receive(:split_path).and_return([nil, nil])
-
-      expect(terminus).not_to be_authorized(request)
-    end
-
-    it "should return true when no auth directives are defined for the mount point" do
-      expect(terminus).to be_authorized(request)
-    end
-  end
-end