puppet 7.30.0-x86-mingw32 → 8.0.1-x86-mingw32

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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,57 @@
+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

@@ -0,0 +1,194 @@
+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

@@ -0,0 +1,116 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,288 @@
+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